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.1
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef 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 >= 0x03000000
788  char *newstr = 0;
789  str = PyUnicode_AsUTF8String(str);
790  if (str) {
791  char *cstr;
792  Py_ssize_t len;
793  PyBytes_AsStringAndSize(str, &cstr, &len);
794  newstr = (char *) malloc(len+1);
795  memcpy(newstr, cstr, len+1);
796  Py_XDECREF(str);
797  }
798  return newstr;
799 #else
800  return PyString_AsString(str);
801 #endif
802 }
803 
804 #if PY_VERSION_HEX >= 0x03000000
805 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
806 #else
807 # define SWIG_Python_str_DelForPy3(x)
808 #endif
809 
810 
811 SWIGINTERN PyObject*
813 {
814 #if PY_VERSION_HEX >= 0x03000000
815  return PyUnicode_FromString(c);
816 #else
817  return PyString_FromString(c);
818 #endif
819 }
820 
821 #ifndef PyObject_DEL
822 # define PyObject_DEL PyObject_Del
823 #endif
824 
825 // SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
826 // interface files check for it.
827 # define SWIGPY_USE_CAPSULE
828 # define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
829 
830 #if PY_VERSION_HEX < 0x03020000
831 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
832 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
833 #define Py_hash_t long
834 #endif
835 
836 /* -----------------------------------------------------------------------------
837  * error manipulation
838  * ----------------------------------------------------------------------------- */
839 
840 SWIGRUNTIME PyObject*
842  PyObject* type = 0;
843  switch(code) {
844  case SWIG_MemoryError:
845  type = PyExc_MemoryError;
846  break;
847  case SWIG_IOError:
848  type = PyExc_IOError;
849  break;
850  case SWIG_RuntimeError:
851  type = PyExc_RuntimeError;
852  break;
853  case SWIG_IndexError:
854  type = PyExc_IndexError;
855  break;
856  case SWIG_TypeError:
857  type = PyExc_TypeError;
858  break;
859  case SWIG_DivisionByZero:
860  type = PyExc_ZeroDivisionError;
861  break;
862  case SWIG_OverflowError:
863  type = PyExc_OverflowError;
864  break;
865  case SWIG_SyntaxError:
866  type = PyExc_SyntaxError;
867  break;
868  case SWIG_ValueError:
869  type = PyExc_ValueError;
870  break;
871  case SWIG_SystemError:
872  type = PyExc_SystemError;
873  break;
874  case SWIG_AttributeError:
875  type = PyExc_AttributeError;
876  break;
877  default:
878  type = PyExc_RuntimeError;
879  }
880  return type;
881 }
882 
883 
884 SWIGRUNTIME void
885 SWIG_Python_AddErrorMsg(const char* mesg)
886 {
887  PyObject *type = 0;
888  PyObject *value = 0;
889  PyObject *traceback = 0;
890 
891  if (PyErr_Occurred())
892  PyErr_Fetch(&type, &value, &traceback);
893  if (value) {
894  PyObject *old_str = PyObject_Str(value);
895  const char *tmp = SWIG_Python_str_AsChar(old_str);
896  PyErr_Clear();
897  Py_XINCREF(type);
898  if (tmp)
899  PyErr_Format(type, "%s %s", tmp, mesg);
900  else
901  PyErr_Format(type, "%s", mesg);
903  Py_DECREF(old_str);
904  Py_DECREF(value);
905  } else {
906  PyErr_SetString(PyExc_RuntimeError, mesg);
907  }
908 }
909 
910 SWIGRUNTIME int
912 {
913  PyObject *error;
914  if (obj)
915  return 0;
916  error = PyErr_Occurred();
917  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
918 }
919 
920 SWIGRUNTIME void
922 {
923  if (SWIG_Python_TypeErrorOccurred(NULL)) {
924  /* Use existing TypeError to preserve stacktrace and enhance with given message */
925  PyObject *newvalue;
926  PyObject *type = NULL, *value = NULL, *traceback = NULL;
927  PyErr_Fetch(&type, &value, &traceback);
928 #if PY_VERSION_HEX >= 0x03000000
929  newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
930 #else
931  newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
932 #endif
933  Py_XDECREF(value);
934  PyErr_Restore(type, newvalue, traceback);
935  } else {
936  /* Raise TypeError using given message */
937  PyErr_SetString(PyExc_TypeError, message);
938  }
939 }
940 
941 #if defined(SWIG_PYTHON_NO_THREADS)
942 # if defined(SWIG_PYTHON_THREADS)
943 # undef SWIG_PYTHON_THREADS
944 # endif
945 #endif
946 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
947 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
948 # define SWIG_PYTHON_USE_GIL
949 # endif
950 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
951 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
952 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
953 # endif
954 # ifdef __cplusplus /* C++ code */
955  class SWIG_Python_Thread_Block {
956  bool status;
957  PyGILState_STATE state;
958  public:
959  void end() { if (status) { PyGILState_Release(state); status = false;} }
960  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
961  ~SWIG_Python_Thread_Block() { end(); }
962  };
963  class SWIG_Python_Thread_Allow {
964  bool status;
965  PyThreadState *save;
966  public:
967  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
968  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
969  ~SWIG_Python_Thread_Allow() { end(); }
970  };
971 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
972 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
973 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
974 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
975 # else /* C code */
976 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
977 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
978 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
979 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
980 # endif
981 # else /* Old thread way, not implemented, user must provide it */
982 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
983 # define SWIG_PYTHON_INITIALIZE_THREADS
984 # endif
985 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
986 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
987 # endif
988 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
989 # define SWIG_PYTHON_THREAD_END_BLOCK
990 # endif
991 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
992 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
993 # endif
994 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
995 # define SWIG_PYTHON_THREAD_END_ALLOW
996 # endif
997 # endif
998 #else /* No thread support */
999 # define SWIG_PYTHON_INITIALIZE_THREADS
1000 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1001 # define SWIG_PYTHON_THREAD_END_BLOCK
1002 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1003 # define SWIG_PYTHON_THREAD_END_ALLOW
1004 #endif
1005 
1006 /* -----------------------------------------------------------------------------
1007  * Python API portion that goes into the runtime
1008  * ----------------------------------------------------------------------------- */
1009 
1010 #ifdef __cplusplus
1011 extern "C" {
1012 #endif
1013 
1014 /* -----------------------------------------------------------------------------
1015  * Constant declarations
1016  * ----------------------------------------------------------------------------- */
1017 
1018 /* Constant Types */
1019 #define SWIG_PY_POINTER 4
1020 #define SWIG_PY_BINARY 5
1021 
1022 /* Constant information structure */
1023 typedef struct swig_const_info {
1024  int type;
1025  const char *name;
1026  long lvalue;
1027  double dvalue;
1028  void *pvalue;
1030 } swig_const_info;
1031 
1032 #ifdef __cplusplus
1033 }
1034 #endif
1035 
1036 
1037 /* -----------------------------------------------------------------------------
1038  * pyrun.swg
1039  *
1040  * This file contains the runtime support for Python modules
1041  * and includes code for managing global variables and pointer
1042  * type checking.
1043  *
1044  * ----------------------------------------------------------------------------- */
1045 
1046 #if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1047 # error "This version of SWIG only supports Python >= 2.7"
1048 #endif
1049 
1050 #if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1051 # error "This version of SWIG only supports Python 3 >= 3.2"
1052 #endif
1053 
1054 /* Common SWIG API */
1055 
1056 /* for raw pointers */
1057 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1058 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1059 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1060 
1061 #ifdef SWIGPYTHON_BUILTIN
1062 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1063 #else
1064 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1065 #endif
1066 
1067 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1068 
1069 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1070 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1071 #define swig_owntype int
1072 
1073 /* for raw packed data */
1074 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1075 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1076 
1077 /* for class or struct pointers */
1078 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1079 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1080 
1081 /* for C or C++ function pointers */
1082 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1083 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1084 
1085 /* for C++ member pointers, ie, member methods */
1086 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1087 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1088 
1089 
1090 /* Runtime API */
1091 
1092 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1093 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1094 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1095 
1096 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1097 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1098 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1099 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1100 #define SWIG_fail goto fail
1101 
1102 
1103 /* Runtime API implementation */
1104 
1105 /* Error manipulation */
1106 
1107 SWIGINTERN void
1108 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1110  PyErr_SetObject(errtype, obj);
1111  Py_DECREF(obj);
1113 }
1114 
1115 SWIGINTERN void
1116 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1118  PyErr_SetString(errtype, msg);
1120 }
1121 
1122 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1123 
1124 /* Set a constant value */
1125 
1126 #if defined(SWIGPYTHON_BUILTIN)
1127 
1128 SWIGINTERN void
1129 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1130  PyObject *s = PyString_InternFromString(key);
1131  PyList_Append(seq, s);
1132  Py_DECREF(s);
1133 }
1134 
1135 SWIGINTERN void
1136 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1137  PyDict_SetItemString(d, name, obj);
1138  Py_DECREF(obj);
1139  if (public_interface)
1140  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1141 }
1142 
1143 #else
1144 
1145 SWIGINTERN void
1146 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1147  PyDict_SetItemString(d, name, obj);
1148  Py_DECREF(obj);
1149 }
1150 
1151 #endif
1152 
1153 /* Append a value to the result obj */
1154 
1155 SWIGINTERN PyObject*
1156 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1157  if (!result) {
1158  result = obj;
1159  } else if (result == Py_None) {
1160  Py_DECREF(result);
1161  result = obj;
1162  } else {
1163  if (!PyList_Check(result)) {
1164  PyObject *o2 = result;
1165  result = PyList_New(1);
1166  PyList_SetItem(result, 0, o2);
1167  }
1168  PyList_Append(result,obj);
1169  Py_DECREF(obj);
1170  }
1171  return result;
1172 }
1173 
1174 /* Unpack the argument tuple */
1175 
1176 SWIGINTERN Py_ssize_t
1177 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1178 {
1179  if (!args) {
1180  if (!min && !max) {
1181  return 1;
1182  } else {
1183  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1184  name, (min == max ? "" : "at least "), (int)min);
1185  return 0;
1186  }
1187  }
1188  if (!PyTuple_Check(args)) {
1189  if (min <= 1 && max >= 1) {
1190  Py_ssize_t i;
1191  objs[0] = args;
1192  for (i = 1; i < max; ++i) {
1193  objs[i] = 0;
1194  }
1195  return 2;
1196  }
1197  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1198  return 0;
1199  } else {
1200  Py_ssize_t l = PyTuple_GET_SIZE(args);
1201  if (l < min) {
1202  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1203  name, (min == max ? "" : "at least "), (int)min, (int)l);
1204  return 0;
1205  } else if (l > max) {
1206  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1207  name, (min == max ? "" : "at most "), (int)max, (int)l);
1208  return 0;
1209  } else {
1210  Py_ssize_t i;
1211  for (i = 0; i < l; ++i) {
1212  objs[i] = PyTuple_GET_ITEM(args, i);
1213  }
1214  for (; l < max; ++l) {
1215  objs[l] = 0;
1216  }
1217  return i + 1;
1218  }
1219  }
1220 }
1221 
1222 /* A functor is a function object with one single object argument */
1223 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1224 
1225 /*
1226  Helper for static pointer initialization for both C and C++ code, for example
1227  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1228 */
1229 #ifdef __cplusplus
1230 #define SWIG_STATIC_POINTER(var) var
1231 #else
1232 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1233 #endif
1234 
1235 /* -----------------------------------------------------------------------------
1236  * Pointer declarations
1237  * ----------------------------------------------------------------------------- */
1238 
1239 /* Flags for new pointer objects */
1240 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1241 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1242 
1243 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1244 
1245 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1246 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1247 
1248 #ifdef __cplusplus
1249 extern "C" {
1250 #endif
1251 
1252 /* The python void return value */
1253 
1254 SWIGRUNTIMEINLINE PyObject *
1256 {
1257  PyObject *none = Py_None;
1258  Py_INCREF(none);
1259  return none;
1260 }
1261 
1262 /* SwigPyClientData */
1263 
1264 typedef struct {
1265  PyObject *klass;
1266  PyObject *newraw;
1267  PyObject *newargs;
1268  PyObject *destroy;
1269  int delargs;
1271  PyTypeObject *pytype;
1273 
1274 SWIGRUNTIMEINLINE int
1276 {
1278  int fail = data ? data->implicitconv : 0;
1279  if (fail)
1280  PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1281  return fail;
1282 }
1283 
1284 SWIGRUNTIMEINLINE PyObject *
1286  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1287  PyObject *klass = data ? data->klass : 0;
1288  return (klass ? klass : PyExc_RuntimeError);
1289 }
1290 
1291 
1293 SwigPyClientData_New(PyObject* obj)
1294 {
1295  if (!obj) {
1296  return 0;
1297  } else {
1298  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1299  /* the klass element */
1300  data->klass = obj;
1301  Py_INCREF(data->klass);
1302  /* the newraw method and newargs arguments used to create a new raw instance */
1303  if (PyClass_Check(obj)) {
1304  data->newraw = 0;
1305  data->newargs = obj;
1306  Py_INCREF(obj);
1307  } else {
1308  data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1309  if (data->newraw) {
1310  Py_INCREF(data->newraw);
1311  data->newargs = PyTuple_New(1);
1312  PyTuple_SetItem(data->newargs, 0, obj);
1313  } else {
1314  data->newargs = obj;
1315  }
1316  Py_INCREF(data->newargs);
1317  }
1318  /* the destroy method, aka as the C++ delete method */
1319  data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1320  if (PyErr_Occurred()) {
1321  PyErr_Clear();
1322  data->destroy = 0;
1323  }
1324  if (data->destroy) {
1325  int flags;
1326  Py_INCREF(data->destroy);
1327  flags = PyCFunction_GET_FLAGS(data->destroy);
1328  data->delargs = !(flags & (METH_O));
1329  } else {
1330  data->delargs = 0;
1331  }
1332  data->implicitconv = 0;
1333  data->pytype = 0;
1334  return data;
1335  }
1336 }
1337 
1338 SWIGRUNTIME void
1340  Py_XDECREF(data->newraw);
1341  Py_XDECREF(data->newargs);
1342  Py_XDECREF(data->destroy);
1343 }
1344 
1345 /* =============== SwigPyObject =====================*/
1346 
1347 typedef struct {
1348  PyObject_HEAD
1349  void *ptr;
1351  int own;
1352  PyObject *next;
1353 #ifdef SWIGPYTHON_BUILTIN
1354  PyObject *dict;
1355 #endif
1356 } SwigPyObject;
1357 
1358 
1359 #ifdef SWIGPYTHON_BUILTIN
1360 
1361 SWIGRUNTIME PyObject *
1362 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1363 {
1364  SwigPyObject *sobj = (SwigPyObject *)v;
1365 
1366  if (!sobj->dict)
1367  sobj->dict = PyDict_New();
1368 
1369  Py_INCREF(sobj->dict);
1370  return sobj->dict;
1371 }
1372 
1373 #endif
1374 
1375 SWIGRUNTIME PyObject *
1377 {
1378  return PyLong_FromVoidPtr(v->ptr);
1379 }
1380 
1381 SWIGRUNTIME PyObject *
1382 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1383 {
1384  PyObject *res = NULL;
1385  PyObject *args = PyTuple_New(1);
1386  if (args) {
1387  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1388  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1389  if (ofmt) {
1390 #if PY_VERSION_HEX >= 0x03000000
1391  res = PyUnicode_Format(ofmt,args);
1392 #else
1393  res = PyString_Format(ofmt,args);
1394 #endif
1395  Py_DECREF(ofmt);
1396  }
1397  Py_DECREF(args);
1398  }
1399  }
1400  return res;
1401 }
1402 
1403 SWIGRUNTIME PyObject *
1405 {
1406  return SwigPyObject_format("%o",v);
1407 }
1408 
1409 SWIGRUNTIME PyObject *
1411 {
1412  return SwigPyObject_format("%x",v);
1413 }
1414 
1415 SWIGRUNTIME PyObject *
1417 {
1418  const char *name = SWIG_TypePrettyName(v->ty);
1419  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1420  if (v->next) {
1421  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1422 # if PY_VERSION_HEX >= 0x03000000
1423  PyObject *joined = PyUnicode_Concat(repr, nrep);
1424  Py_DecRef(repr);
1425  Py_DecRef(nrep);
1426  repr = joined;
1427 # else
1428  PyString_ConcatAndDel(&repr,nrep);
1429 # endif
1430  }
1431  return repr;
1432 }
1433 
1434 /* We need a version taking two PyObject* parameters so it's a valid
1435  * PyCFunction to use in swigobject_methods[]. */
1436 SWIGRUNTIME PyObject *
1437 SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1438 {
1439  return SwigPyObject_repr((SwigPyObject*)v);
1440 }
1441 
1442 SWIGRUNTIME int
1444 {
1445  void *i = v->ptr;
1446  void *j = w->ptr;
1447  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1448 }
1449 
1450 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1451 SWIGRUNTIME PyObject*
1453 {
1454  PyObject* res;
1455  if( op != Py_EQ && op != Py_NE ) {
1456  Py_INCREF(Py_NotImplemented);
1457  return Py_NotImplemented;
1458  }
1459  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1460  return res;
1461 }
1462 
1463 
1464 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1465 
1466 #ifdef SWIGPYTHON_BUILTIN
1467 static swig_type_info *SwigPyObject_stype = 0;
1468 SWIGRUNTIME PyTypeObject*
1469 SwigPyObject_type(void) {
1470  SwigPyClientData *cd;
1471  assert(SwigPyObject_stype);
1472  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1473  assert(cd);
1474  assert(cd->pytype);
1475  return cd->pytype;
1476 }
1477 #else
1478 SWIGRUNTIME PyTypeObject*
1480  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1481  return type;
1482 }
1483 #endif
1484 
1486 SwigPyObject_Check(PyObject *op) {
1487 #ifdef SWIGPYTHON_BUILTIN
1488  PyTypeObject *target_tp = SwigPyObject_type();
1489  if (PyType_IsSubtype(op->ob_type, target_tp))
1490  return 1;
1491  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1492 #else
1493  return (Py_TYPE(op) == SwigPyObject_type())
1494  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1495 #endif
1496 }
1497 
1498 SWIGRUNTIME PyObject *
1499 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1500 
1501 SWIGRUNTIME void
1503 {
1504  SwigPyObject *sobj = (SwigPyObject *) v;
1505  PyObject *next = sobj->next;
1506  if (sobj->own == SWIG_POINTER_OWN) {
1507  swig_type_info *ty = sobj->ty;
1508  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1509  PyObject *destroy = data ? data->destroy : 0;
1510  if (destroy) {
1511  /* destroy is always a VARARGS method */
1512  PyObject *res;
1513 
1514  /* PyObject_CallFunction() has the potential to silently drop
1515  the active exception. In cases of unnamed temporary
1516  variable or where we just finished iterating over a generator
1517  StopIteration will be active right now, and this needs to
1518  remain true upon return from SwigPyObject_dealloc. So save
1519  and restore. */
1520 
1521  PyObject *type = NULL, *value = NULL, *traceback = NULL;
1522  PyErr_Fetch(&type, &value, &traceback);
1523 
1524  if (data->delargs) {
1525  /* we need to create a temporary object to carry the destroy operation */
1526  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1527  res = SWIG_Python_CallFunctor(destroy, tmp);
1528  Py_DECREF(tmp);
1529  } else {
1530  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1531  PyObject *mself = PyCFunction_GET_SELF(destroy);
1532  res = ((*meth)(mself, v));
1533  }
1534  if (!res)
1535  PyErr_WriteUnraisable(destroy);
1536 
1537  PyErr_Restore(type, value, traceback);
1538 
1539  Py_XDECREF(res);
1540  }
1541 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1542  else {
1543  const char *name = SWIG_TypePrettyName(ty);
1544  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1545  }
1546 #endif
1547  }
1548  Py_XDECREF(next);
1549  PyObject_DEL(v);
1550 }
1551 
1552 SWIGRUNTIME PyObject*
1553 SwigPyObject_append(PyObject* v, PyObject* next)
1554 {
1555  SwigPyObject *sobj = (SwigPyObject *) v;
1556  if (!SwigPyObject_Check(next)) {
1557  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1558  return NULL;
1559  }
1560  sobj->next = next;
1561  Py_INCREF(next);
1562  return SWIG_Py_Void();
1563 }
1564 
1565 SWIGRUNTIME PyObject*
1566 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1567 {
1568  SwigPyObject *sobj = (SwigPyObject *) v;
1569  if (sobj->next) {
1570  Py_INCREF(sobj->next);
1571  return sobj->next;
1572  } else {
1573  return SWIG_Py_Void();
1574  }
1575 }
1576 
1577 SWIGINTERN PyObject*
1578 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1579 {
1580  SwigPyObject *sobj = (SwigPyObject *)v;
1581  sobj->own = 0;
1582  return SWIG_Py_Void();
1583 }
1584 
1585 SWIGINTERN PyObject*
1586 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1587 {
1588  SwigPyObject *sobj = (SwigPyObject *)v;
1589  sobj->own = SWIG_POINTER_OWN;
1590  return SWIG_Py_Void();
1591 }
1592 
1593 SWIGINTERN PyObject*
1594 SwigPyObject_own(PyObject *v, PyObject *args)
1595 {
1596  PyObject *val = 0;
1597  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1598  return NULL;
1599  } else {
1600  SwigPyObject *sobj = (SwigPyObject *)v;
1601  PyObject *obj = PyBool_FromLong(sobj->own);
1602  if (val) {
1603  if (PyObject_IsTrue(val)) {
1604  SwigPyObject_acquire(v,args);
1605  } else {
1606  SwigPyObject_disown(v,args);
1607  }
1608  }
1609  return obj;
1610  }
1611 }
1612 
1613 static PyMethodDef
1615  {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1616  {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1617  {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1618  {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1619  {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1620  {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1621  {0, 0, 0, 0}
1622 };
1623 
1624 SWIGRUNTIME PyTypeObject*
1626  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1627 
1628  static PyNumberMethods SwigPyObject_as_number = {
1629  (binaryfunc)0, /*nb_add*/
1630  (binaryfunc)0, /*nb_subtract*/
1631  (binaryfunc)0, /*nb_multiply*/
1632  /* nb_divide removed in Python 3 */
1633 #if PY_VERSION_HEX < 0x03000000
1634  (binaryfunc)0, /*nb_divide*/
1635 #endif
1636  (binaryfunc)0, /*nb_remainder*/
1637  (binaryfunc)0, /*nb_divmod*/
1638  (ternaryfunc)0,/*nb_power*/
1639  (unaryfunc)0, /*nb_negative*/
1640  (unaryfunc)0, /*nb_positive*/
1641  (unaryfunc)0, /*nb_absolute*/
1642  (inquiry)0, /*nb_nonzero*/
1643  0, /*nb_invert*/
1644  0, /*nb_lshift*/
1645  0, /*nb_rshift*/
1646  0, /*nb_and*/
1647  0, /*nb_xor*/
1648  0, /*nb_or*/
1649 #if PY_VERSION_HEX < 0x03000000
1650  0, /*nb_coerce*/
1651 #endif
1652  (unaryfunc)SwigPyObject_long, /*nb_int*/
1653 #if PY_VERSION_HEX < 0x03000000
1654  (unaryfunc)SwigPyObject_long, /*nb_long*/
1655 #else
1656  0, /*nb_reserved*/
1657 #endif
1658  (unaryfunc)0, /*nb_float*/
1659 #if PY_VERSION_HEX < 0x03000000
1660  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1661  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1662 #endif
1663 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1664  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1665 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1666  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1667 #else
1668  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1669 #endif
1670  };
1671 
1672  static PyTypeObject swigpyobject_type;
1673  static int type_init = 0;
1674  if (!type_init) {
1675  const PyTypeObject tmp = {
1676 #if PY_VERSION_HEX >= 0x03000000
1677  PyVarObject_HEAD_INIT(NULL, 0)
1678 #else
1679  PyObject_HEAD_INIT(NULL)
1680  0, /* ob_size */
1681 #endif
1682  "SwigPyObject", /* tp_name */
1683  sizeof(SwigPyObject), /* tp_basicsize */
1684  0, /* tp_itemsize */
1685  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1686  0, /* tp_print */
1687  (getattrfunc)0, /* tp_getattr */
1688  (setattrfunc)0, /* tp_setattr */
1689 #if PY_VERSION_HEX >= 0x03000000
1690  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1691 #else
1692  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1693 #endif
1694  (reprfunc)SwigPyObject_repr, /* tp_repr */
1695  &SwigPyObject_as_number, /* tp_as_number */
1696  0, /* tp_as_sequence */
1697  0, /* tp_as_mapping */
1698  (hashfunc)0, /* tp_hash */
1699  (ternaryfunc)0, /* tp_call */
1700  0, /* tp_str */
1701  PyObject_GenericGetAttr, /* tp_getattro */
1702  0, /* tp_setattro */
1703  0, /* tp_as_buffer */
1704  Py_TPFLAGS_DEFAULT, /* tp_flags */
1705  swigobject_doc, /* tp_doc */
1706  0, /* tp_traverse */
1707  0, /* tp_clear */
1708  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1709  0, /* tp_weaklistoffset */
1710  0, /* tp_iter */
1711  0, /* tp_iternext */
1712  swigobject_methods, /* tp_methods */
1713  0, /* tp_members */
1714  0, /* tp_getset */
1715  0, /* tp_base */
1716  0, /* tp_dict */
1717  0, /* tp_descr_get */
1718  0, /* tp_descr_set */
1719  0, /* tp_dictoffset */
1720  0, /* tp_init */
1721  0, /* tp_alloc */
1722  0, /* tp_new */
1723  0, /* tp_free */
1724  0, /* tp_is_gc */
1725  0, /* tp_bases */
1726  0, /* tp_mro */
1727  0, /* tp_cache */
1728  0, /* tp_subclasses */
1729  0, /* tp_weaklist */
1730  0, /* tp_del */
1731  0, /* tp_version_tag */
1732 #if PY_VERSION_HEX >= 0x03040000
1733  0, /* tp_finalize */
1734 #endif
1735 #ifdef COUNT_ALLOCS
1736  0, /* tp_allocs */
1737  0, /* tp_frees */
1738  0, /* tp_maxalloc */
1739  0, /* tp_prev */
1740  0 /* tp_next */
1741 #endif
1742  };
1743  swigpyobject_type = tmp;
1744  type_init = 1;
1745  if (PyType_Ready(&swigpyobject_type) < 0)
1746  return NULL;
1747  }
1748  return &swigpyobject_type;
1749 }
1750 
1751 SWIGRUNTIME PyObject *
1752 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1753 {
1754  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1755  if (sobj) {
1756  sobj->ptr = ptr;
1757  sobj->ty = ty;
1758  sobj->own = own;
1759  sobj->next = 0;
1760  }
1761  return (PyObject *)sobj;
1762 }
1763 
1764 /* -----------------------------------------------------------------------------
1765  * Implements a simple Swig Packed type, and use it instead of string
1766  * ----------------------------------------------------------------------------- */
1767 
1768 typedef struct {
1769  PyObject_HEAD
1770  void *pack;
1772  size_t size;
1773 } SwigPyPacked;
1774 
1775 SWIGRUNTIME PyObject *
1777 {
1778  char result[SWIG_BUFFER_SIZE];
1779  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1780  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1781  } else {
1782  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1783  }
1784 }
1785 
1786 SWIGRUNTIME PyObject *
1788 {
1789  char result[SWIG_BUFFER_SIZE];
1790  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1791  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1792  } else {
1793  return SWIG_Python_str_FromChar(v->ty->name);
1794  }
1795 }
1796 
1797 SWIGRUNTIME int
1799 {
1800  size_t i = v->size;
1801  size_t j = w->size;
1802  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1803  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1804 }
1805 
1806 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1807 
1808 SWIGRUNTIME PyTypeObject*
1810  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1811  return type;
1812 }
1813 
1815 SwigPyPacked_Check(PyObject *op) {
1816  return ((op)->ob_type == SwigPyPacked_TypeOnce())
1817  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1818 }
1819 
1820 SWIGRUNTIME void
1822 {
1823  if (SwigPyPacked_Check(v)) {
1824  SwigPyPacked *sobj = (SwigPyPacked *) v;
1825  free(sobj->pack);
1826  }
1827  PyObject_DEL(v);
1828 }
1829 
1830 SWIGRUNTIME PyTypeObject*
1832  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1833  static PyTypeObject swigpypacked_type;
1834  static int type_init = 0;
1835  if (!type_init) {
1836  const PyTypeObject tmp = {
1837 #if PY_VERSION_HEX>=0x03000000
1838  PyVarObject_HEAD_INIT(NULL, 0)
1839 #else
1840  PyObject_HEAD_INIT(NULL)
1841  0, /* ob_size */
1842 #endif
1843  "SwigPyPacked", /* tp_name */
1844  sizeof(SwigPyPacked), /* tp_basicsize */
1845  0, /* tp_itemsize */
1846  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1847  0, /* tp_print */
1848  (getattrfunc)0, /* tp_getattr */
1849  (setattrfunc)0, /* tp_setattr */
1850 #if PY_VERSION_HEX>=0x03000000
1851  0, /* tp_reserved in 3.0.1 */
1852 #else
1853  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1854 #endif
1855  (reprfunc)SwigPyPacked_repr, /* tp_repr */
1856  0, /* tp_as_number */
1857  0, /* tp_as_sequence */
1858  0, /* tp_as_mapping */
1859  (hashfunc)0, /* tp_hash */
1860  (ternaryfunc)0, /* tp_call */
1861  (reprfunc)SwigPyPacked_str, /* tp_str */
1862  PyObject_GenericGetAttr, /* tp_getattro */
1863  0, /* tp_setattro */
1864  0, /* tp_as_buffer */
1865  Py_TPFLAGS_DEFAULT, /* tp_flags */
1866  swigpacked_doc, /* tp_doc */
1867  0, /* tp_traverse */
1868  0, /* tp_clear */
1869  0, /* tp_richcompare */
1870  0, /* tp_weaklistoffset */
1871  0, /* tp_iter */
1872  0, /* tp_iternext */
1873  0, /* tp_methods */
1874  0, /* tp_members */
1875  0, /* tp_getset */
1876  0, /* tp_base */
1877  0, /* tp_dict */
1878  0, /* tp_descr_get */
1879  0, /* tp_descr_set */
1880  0, /* tp_dictoffset */
1881  0, /* tp_init */
1882  0, /* tp_alloc */
1883  0, /* tp_new */
1884  0, /* tp_free */
1885  0, /* tp_is_gc */
1886  0, /* tp_bases */
1887  0, /* tp_mro */
1888  0, /* tp_cache */
1889  0, /* tp_subclasses */
1890  0, /* tp_weaklist */
1891  0, /* tp_del */
1892  0, /* tp_version_tag */
1893 #if PY_VERSION_HEX >= 0x03040000
1894  0, /* tp_finalize */
1895 #endif
1896 #ifdef COUNT_ALLOCS
1897  0, /* tp_allocs */
1898  0, /* tp_frees */
1899  0, /* tp_maxalloc */
1900  0, /* tp_prev */
1901  0 /* tp_next */
1902 #endif
1903  };
1904  swigpypacked_type = tmp;
1905  type_init = 1;
1906  if (PyType_Ready(&swigpypacked_type) < 0)
1907  return NULL;
1908  }
1909  return &swigpypacked_type;
1910 }
1911 
1912 SWIGRUNTIME PyObject *
1913 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1914 {
1915  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1916  if (sobj) {
1917  void *pack = malloc(size);
1918  if (pack) {
1919  memcpy(pack, ptr, size);
1920  sobj->pack = pack;
1921  sobj->ty = ty;
1922  sobj->size = size;
1923  } else {
1924  PyObject_DEL((PyObject *) sobj);
1925  sobj = 0;
1926  }
1927  }
1928  return (PyObject *) sobj;
1929 }
1930 
1932 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1933 {
1934  if (SwigPyPacked_Check(obj)) {
1935  SwigPyPacked *sobj = (SwigPyPacked *)obj;
1936  if (sobj->size != size) return 0;
1937  memcpy(ptr, sobj->pack, size);
1938  return sobj->ty;
1939  } else {
1940  return 0;
1941  }
1942 }
1943 
1944 /* -----------------------------------------------------------------------------
1945  * pointers/data manipulation
1946  * ----------------------------------------------------------------------------- */
1947 
1948 static PyObject *Swig_This_global = NULL;
1949 
1950 SWIGRUNTIME PyObject *
1952 {
1953  if (Swig_This_global == NULL)
1955  return Swig_This_global;
1956 }
1957 
1958 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1959 
1960 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
1961 #if PY_VERSION_HEX>=0x03000000
1962 #define SWIG_PYTHON_SLOW_GETSET_THIS
1963 #endif
1964 
1966 SWIG_Python_GetSwigThis(PyObject *pyobj)
1967 {
1968  PyObject *obj;
1969 
1970  if (SwigPyObject_Check(pyobj))
1971  return (SwigPyObject *) pyobj;
1972 
1973 #ifdef SWIGPYTHON_BUILTIN
1974  (void)obj;
1975 # ifdef PyWeakref_CheckProxy
1976  if (PyWeakref_CheckProxy(pyobj)) {
1977  pyobj = PyWeakref_GET_OBJECT(pyobj);
1978  if (pyobj && SwigPyObject_Check(pyobj))
1979  return (SwigPyObject*) pyobj;
1980  }
1981 # endif
1982  return NULL;
1983 #else
1984 
1985  obj = 0;
1986 
1987 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
1988  if (PyInstance_Check(pyobj)) {
1989  obj = _PyInstance_Lookup(pyobj, SWIG_This());
1990  } else {
1991  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1992  if (dictptr != NULL) {
1993  PyObject *dict = *dictptr;
1994  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1995  } else {
1996 #ifdef PyWeakref_CheckProxy
1997  if (PyWeakref_CheckProxy(pyobj)) {
1998  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1999  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2000  }
2001 #endif
2002  obj = PyObject_GetAttr(pyobj,SWIG_This());
2003  if (obj) {
2004  Py_DECREF(obj);
2005  } else {
2006  if (PyErr_Occurred()) PyErr_Clear();
2007  return 0;
2008  }
2009  }
2010  }
2011 #else
2012  obj = PyObject_GetAttr(pyobj,SWIG_This());
2013  if (obj) {
2014  Py_DECREF(obj);
2015  } else {
2016  if (PyErr_Occurred()) PyErr_Clear();
2017  return 0;
2018  }
2019 #endif
2020  if (obj && !SwigPyObject_Check(obj)) {
2021  /* a PyObject is called 'this', try to get the 'real this'
2022  SwigPyObject from it */
2023  return SWIG_Python_GetSwigThis(obj);
2024  }
2025  return (SwigPyObject *)obj;
2026 #endif
2027 }
2028 
2029 /* Acquire a pointer value */
2030 
2031 SWIGRUNTIME int
2032 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2033  if (own == SWIG_POINTER_OWN) {
2035  if (sobj) {
2036  int oldown = sobj->own;
2037  sobj->own = own;
2038  return oldown;
2039  }
2040  }
2041  return 0;
2042 }
2043 
2044 /* Convert a pointer value */
2045 
2046 SWIGRUNTIME int
2047 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2048  int res;
2049  SwigPyObject *sobj;
2050  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2051 
2052  if (!obj)
2053  return SWIG_ERROR;
2054  if (obj == Py_None && !implicit_conv) {
2055  if (ptr)
2056  *ptr = 0;
2058  }
2059 
2060  res = SWIG_ERROR;
2061 
2062  sobj = SWIG_Python_GetSwigThis(obj);
2063  if (own)
2064  *own = 0;
2065  while (sobj) {
2066  void *vptr = sobj->ptr;
2067  if (ty) {
2068  swig_type_info *to = sobj->ty;
2069  if (to == ty) {
2070  /* no type cast needed */
2071  if (ptr) *ptr = vptr;
2072  break;
2073  } else {
2074  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2075  if (!tc) {
2076  sobj = (SwigPyObject *)sobj->next;
2077  } else {
2078  if (ptr) {
2079  int newmemory = 0;
2080  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2081  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2082  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2083  if (own)
2084  *own = *own | SWIG_CAST_NEW_MEMORY;
2085  }
2086  }
2087  break;
2088  }
2089  }
2090  } else {
2091  if (ptr) *ptr = vptr;
2092  break;
2093  }
2094  }
2095  if (sobj) {
2096  if (own)
2097  *own = *own | sobj->own;
2098  if (flags & SWIG_POINTER_DISOWN) {
2099  sobj->own = 0;
2100  }
2101  res = SWIG_OK;
2102  } else {
2103  if (implicit_conv) {
2104  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2105  if (data && !data->implicitconv) {
2106  PyObject *klass = data->klass;
2107  if (klass) {
2108  PyObject *impconv;
2109  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2110  impconv = SWIG_Python_CallFunctor(klass, obj);
2111  data->implicitconv = 0;
2112  if (PyErr_Occurred()) {
2113  PyErr_Clear();
2114  impconv = 0;
2115  }
2116  if (impconv) {
2117  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2118  if (iobj) {
2119  void *vptr;
2120  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2121  if (SWIG_IsOK(res)) {
2122  if (ptr) {
2123  *ptr = vptr;
2124  /* transfer the ownership to 'ptr' */
2125  iobj->own = 0;
2126  res = SWIG_AddCast(res);
2127  res = SWIG_AddNewMask(res);
2128  } else {
2129  res = SWIG_AddCast(res);
2130  }
2131  }
2132  }
2133  Py_DECREF(impconv);
2134  }
2135  }
2136  }
2137  if (!SWIG_IsOK(res) && obj == Py_None) {
2138  if (ptr)
2139  *ptr = 0;
2140  if (PyErr_Occurred())
2141  PyErr_Clear();
2142  res = SWIG_OK;
2143  }
2144  }
2145  }
2146  return res;
2147 }
2148 
2149 /* Convert a function ptr value */
2150 
2151 SWIGRUNTIME int
2152 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2153  if (!PyCFunction_Check(obj)) {
2154  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2155  } else {
2156  void *vptr = 0;
2157  swig_cast_info *tc;
2158 
2159  /* here we get the method pointer for callbacks */
2160  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2161  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2162  if (desc)
2163  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2164  if (!desc)
2165  return SWIG_ERROR;
2166  tc = SWIG_TypeCheck(desc,ty);
2167  if (tc) {
2168  int newmemory = 0;
2169  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2170  assert(!newmemory); /* newmemory handling not yet implemented */
2171  } else {
2172  return SWIG_ERROR;
2173  }
2174  return SWIG_OK;
2175  }
2176 }
2177 
2178 /* Convert a packed pointer value */
2179 
2180 SWIGRUNTIME int
2181 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2182  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2183  if (!to) return SWIG_ERROR;
2184  if (ty) {
2185  if (to != ty) {
2186  /* check type cast? */
2187  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2188  if (!tc) return SWIG_ERROR;
2189  }
2190  }
2191  return SWIG_OK;
2192 }
2193 
2194 /* -----------------------------------------------------------------------------
2195  * Create a new pointer object
2196  * ----------------------------------------------------------------------------- */
2197 
2198 /*
2199  Create a new instance object, without calling __init__, and set the
2200  'this' attribute.
2201 */
2202 
2203 SWIGRUNTIME PyObject*
2205 {
2206  PyObject *inst = 0;
2207  PyObject *newraw = data->newraw;
2208  if (newraw) {
2209  inst = PyObject_Call(newraw, data->newargs, NULL);
2210  if (inst) {
2211 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2212  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2213  if (dictptr != NULL) {
2214  PyObject *dict = *dictptr;
2215  if (dict == NULL) {
2216  dict = PyDict_New();
2217  *dictptr = dict;
2218  PyDict_SetItem(dict, SWIG_This(), swig_this);
2219  }
2220  }
2221 #else
2222  PyObject *key = SWIG_This();
2223  PyObject_SetAttr(inst, key, swig_this);
2224 #endif
2225  }
2226  } else {
2227 #if PY_VERSION_HEX >= 0x03000000
2228  PyObject *empty_args = PyTuple_New(0);
2229  if (empty_args) {
2230  PyObject *empty_kwargs = PyDict_New();
2231  if (empty_kwargs) {
2232  inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2233  Py_DECREF(empty_kwargs);
2234  if (inst) {
2235  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2236  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2237  }
2238  }
2239  Py_DECREF(empty_args);
2240  }
2241 #else
2242  PyObject *dict = PyDict_New();
2243  if (dict) {
2244  PyDict_SetItem(dict, SWIG_This(), swig_this);
2245  inst = PyInstance_NewRaw(data->newargs, dict);
2246  Py_DECREF(dict);
2247  }
2248 #endif
2249  }
2250  return inst;
2251 }
2252 
2253 SWIGRUNTIME void
2254 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2255 {
2256  PyObject *dict;
2257 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2258  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2259  if (dictptr != NULL) {
2260  dict = *dictptr;
2261  if (dict == NULL) {
2262  dict = PyDict_New();
2263  *dictptr = dict;
2264  }
2265  PyDict_SetItem(dict, SWIG_This(), swig_this);
2266  return;
2267  }
2268 #endif
2269  dict = PyObject_GetAttrString(inst, "__dict__");
2270  PyDict_SetItem(dict, SWIG_This(), swig_this);
2271  Py_DECREF(dict);
2272 }
2273 
2274 
2275 SWIGINTERN PyObject *
2277  PyObject *obj[2];
2278  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2279  return NULL;
2280  } else {
2281  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2282  if (sthis) {
2283  SwigPyObject_append((PyObject*) sthis, obj[1]);
2284  } else {
2285  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2286  }
2287  return SWIG_Py_Void();
2288  }
2289 }
2290 
2291 /* Create a new pointer object */
2292 
2293 SWIGRUNTIME PyObject *
2294 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2295  SwigPyClientData *clientdata;
2296  PyObject * robj;
2297  int own;
2298 
2299  if (!ptr)
2300  return SWIG_Py_Void();
2301 
2302  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2303  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2304  if (clientdata && clientdata->pytype) {
2305  SwigPyObject *newobj;
2306  if (flags & SWIG_BUILTIN_TP_INIT) {
2307  newobj = (SwigPyObject*) self;
2308  if (newobj->ptr) {
2309  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2310  while (newobj->next)
2311  newobj = (SwigPyObject *) newobj->next;
2312  newobj->next = next_self;
2313  newobj = (SwigPyObject *)next_self;
2314 #ifdef SWIGPYTHON_BUILTIN
2315  newobj->dict = 0;
2316 #endif
2317  }
2318  } else {
2319  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2320 #ifdef SWIGPYTHON_BUILTIN
2321  newobj->dict = 0;
2322 #endif
2323  }
2324  if (newobj) {
2325  newobj->ptr = ptr;
2326  newobj->ty = type;
2327  newobj->own = own;
2328  newobj->next = 0;
2329  return (PyObject*) newobj;
2330  }
2331  return SWIG_Py_Void();
2332  }
2333 
2334  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2335 
2336  robj = SwigPyObject_New(ptr, type, own);
2337  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2338  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2339  Py_DECREF(robj);
2340  robj = inst;
2341  }
2342  return robj;
2343 }
2344 
2345 /* Create a new packed object */
2346 
2347 SWIGRUNTIMEINLINE PyObject *
2348 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2349  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2350 }
2351 
2352 /* -----------------------------------------------------------------------------*
2353  * Get type list
2354  * -----------------------------------------------------------------------------*/
2355 
2356 #ifdef SWIG_LINK_RUNTIME
2357 void *SWIG_ReturnGlobalTypeList(void *);
2358 #endif
2359 
2362  static void *type_pointer = (void *)0;
2363  /* first check if module already created */
2364  if (!type_pointer) {
2365 #ifdef SWIG_LINK_RUNTIME
2366  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2367 #else
2368  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2369  if (PyErr_Occurred()) {
2370  PyErr_Clear();
2371  type_pointer = (void *)0;
2372  }
2373 #endif
2374  }
2375  return (swig_module_info *) type_pointer;
2376 }
2377 
2378 SWIGRUNTIME void
2380 {
2381  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2382  swig_type_info **types = swig_module->types;
2383  size_t i;
2384  for (i =0; i < swig_module->size; ++i) {
2385  swig_type_info *ty = types[i];
2386  if (ty->owndata) {
2388  if (data) SwigPyClientData_Del(data);
2389  }
2390  }
2391  Py_DECREF(SWIG_This());
2392  Swig_This_global = NULL;
2393 }
2394 
2395 SWIGRUNTIME void
2397 #if PY_VERSION_HEX >= 0x03000000
2398  /* Add a dummy module object into sys.modules */
2399  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2400 #else
2401  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2402  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2403 #endif
2404  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2405  if (pointer && module) {
2406  PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2407  } else {
2408  Py_XDECREF(pointer);
2409  }
2410 }
2411 
2412 /* The python cached type query */
2413 SWIGRUNTIME PyObject *
2415  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2416  return cache;
2417 }
2418 
2420 SWIG_Python_TypeQuery(const char *type)
2421 {
2422  PyObject *cache = SWIG_Python_TypeCache();
2423  PyObject *key = SWIG_Python_str_FromChar(type);
2424  PyObject *obj = PyDict_GetItem(cache, key);
2425  swig_type_info *descriptor;
2426  if (obj) {
2427  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2428  } else {
2430  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2431  if (descriptor) {
2432  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2433  PyDict_SetItem(cache, key, obj);
2434  Py_DECREF(obj);
2435  }
2436  }
2437  Py_DECREF(key);
2438  return descriptor;
2439 }
2440 
2441 /*
2442  For backward compatibility only
2443 */
2444 #define SWIG_POINTER_EXCEPTION 0
2445 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2446 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2447 
2448 SWIGRUNTIME int
2449 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2450 {
2451  if (PyErr_Occurred()) {
2452  PyObject *type = 0;
2453  PyObject *value = 0;
2454  PyObject *traceback = 0;
2455  PyErr_Fetch(&type, &value, &traceback);
2456  if (value) {
2457  PyObject *old_str = PyObject_Str(value);
2458  const char *tmp = SWIG_Python_str_AsChar(old_str);
2459  const char *errmesg = tmp ? tmp : "Invalid error message";
2460  Py_XINCREF(type);
2461  PyErr_Clear();
2462  if (infront) {
2463  PyErr_Format(type, "%s %s", mesg, errmesg);
2464  } else {
2465  PyErr_Format(type, "%s %s", errmesg, mesg);
2466  }
2468  Py_DECREF(old_str);
2469  }
2470  return 1;
2471  } else {
2472  return 0;
2473  }
2474 }
2475 
2476 SWIGRUNTIME int
2478 {
2479  if (PyErr_Occurred()) {
2480  /* add information about failing argument */
2481  char mesg[256];
2482  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2483  return SWIG_Python_AddErrMesg(mesg, 1);
2484  } else {
2485  return 0;
2486  }
2487 }
2488 
2489 SWIGRUNTIMEINLINE const char *
2490 SwigPyObject_GetDesc(PyObject *self)
2491 {
2492  SwigPyObject *v = (SwigPyObject *)self;
2493  swig_type_info *ty = v ? v->ty : 0;
2494  return ty ? ty->str : "";
2495 }
2496 
2497 SWIGRUNTIME void
2498 SWIG_Python_TypeError(const char *type, PyObject *obj)
2499 {
2500  if (type) {
2501 #if defined(SWIG_COBJECT_TYPES)
2502  if (obj && SwigPyObject_Check(obj)) {
2503  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2504  if (otype) {
2505  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2506  type, otype);
2507  return;
2508  }
2509  } else
2510 #endif
2511  {
2512  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2513  if (otype) {
2514  PyObject *str = PyObject_Str(obj);
2515  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2516  if (cstr) {
2517  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2518  type, otype, cstr);
2520  } else {
2521  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2522  type, otype);
2523  }
2524  Py_XDECREF(str);
2525  return;
2526  }
2527  }
2528  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2529  } else {
2530  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2531  }
2532 }
2533 
2534 
2535 /* Convert a pointer value, signal an exception on a type mismatch */
2536 SWIGRUNTIME void *
2537 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2538  void *result;
2539  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2540  PyErr_Clear();
2541 #if SWIG_POINTER_EXCEPTION
2542  if (flags) {
2544  SWIG_Python_ArgFail(argnum);
2545  }
2546 #endif
2547  }
2548  return result;
2549 }
2550 
2551 #ifdef SWIGPYTHON_BUILTIN
2552 SWIGRUNTIME int
2553 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2554  PyTypeObject *tp = obj->ob_type;
2555  PyObject *descr;
2556  PyObject *encoded_name;
2557  descrsetfunc f;
2558  int res = -1;
2559 
2560 # ifdef Py_USING_UNICODE
2561  if (PyString_Check(name)) {
2562  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2563  if (!name)
2564  return -1;
2565  } else if (!PyUnicode_Check(name))
2566 # else
2567  if (!PyString_Check(name))
2568 # endif
2569  {
2570  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2571  return -1;
2572  } else {
2573  Py_INCREF(name);
2574  }
2575 
2576  if (!tp->tp_dict) {
2577  if (PyType_Ready(tp) < 0)
2578  goto done;
2579  }
2580 
2581  descr = _PyType_Lookup(tp, name);
2582  f = NULL;
2583  if (descr != NULL)
2584  f = descr->ob_type->tp_descr_set;
2585  if (!f) {
2586  if (PyString_Check(name)) {
2587  encoded_name = name;
2588  Py_INCREF(name);
2589  } else {
2590  encoded_name = PyUnicode_AsUTF8String(name);
2591  if (!encoded_name)
2592  return -1;
2593  }
2594  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2595  Py_DECREF(encoded_name);
2596  } else {
2597  res = f(descr, obj, value);
2598  }
2599 
2600  done:
2601  Py_DECREF(name);
2602  return res;
2603 }
2604 #endif
2605 
2606 
2607 #ifdef __cplusplus
2608 }
2609 #endif
2610 
2611 
2612 
2613 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2614 
2615 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2616 
2617 
2618 
2619 #ifdef __cplusplus
2620 extern "C" {
2621 #endif
2622 
2623 /* Method creation and docstring support functions */
2624 
2625 SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
2626 SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2627 SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2628 
2629 #ifdef __cplusplus
2630 }
2631 #endif
2632 
2633 
2634 /* -------- TYPES TABLE (BEGIN) -------- */
2635 
2636 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2637 #define SWIGTYPE_p_PLcGrid swig_types[1]
2638 #define SWIGTYPE_p_PLcGrid2 swig_types[2]
2639 #define SWIGTYPE_p_char swig_types[3]
2640 #define SWIGTYPE_p_double swig_types[4]
2641 #define SWIGTYPE_p_f_double_double__int swig_types[5]
2642 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2643 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2644 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2645 #define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2646 #define SWIGTYPE_p_int swig_types[10]
2647 #define SWIGTYPE_p_p_char swig_types[11]
2648 #define SWIGTYPE_p_p_double swig_types[12]
2649 #define SWIGTYPE_p_unsigned_int swig_types[13]
2651 static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2652 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2653 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2654 
2655 /* -------- TYPES TABLE (END) -------- */
2656 
2657 #ifdef SWIG_TypeQuery
2658 # undef SWIG_TypeQuery
2659 #endif
2660 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2661 
2662 /*-----------------------------------------------
2663  @(target):= _plplotc.so
2664  ------------------------------------------------*/
2665 #if PY_VERSION_HEX >= 0x03000000
2666 # define SWIG_init PyInit__plplotc
2667 
2668 #else
2669 # define SWIG_init init_plplotc
2670 
2671 #endif
2672 #define SWIG_name "_plplotc"
2673 
2674 #define SWIGVERSION 0x040001
2675 #define SWIG_VERSION SWIGVERSION
2676 
2677 
2678 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2679 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2680 
2681 
2682 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2683 #include <arrayobject.h>
2684 #include "plplot.h"
2685 #include "plplotP.h"
2686 
2687 #define NPY_PLINT NPY_INT32
2688 
2689 #ifdef PL_DOUBLE
2690 #define NPY_PLFLT NPY_FLOAT64
2691 #else
2692 #define NPY_PLFLT NPY_FLOAT32
2693 #endif
2694 
2695 // python-1.5 compatibility mode?
2696 #if !defined ( PySequence_Fast_GET_ITEM )
2697  #define PySequence_Fast_GET_ITEM PySequence_GetItem
2698 #endif
2699 #define PySequence_Size PySequence_Length
2700 
2701 
2702  static PLINT Alen = 0;
2703  static PLINT Xlen = 0, Ylen = 0;
2704 
2705 
2706 SWIGINTERN int
2707 SWIG_AsVal_double (PyObject *obj, double *val)
2708 {
2709  int res = SWIG_TypeError;
2710  if (PyFloat_Check(obj)) {
2711  if (val) *val = PyFloat_AsDouble(obj);
2712  return SWIG_OK;
2713 #if PY_VERSION_HEX < 0x03000000
2714  } else if (PyInt_Check(obj)) {
2715  if (val) *val = (double) PyInt_AsLong(obj);
2716  return SWIG_OK;
2717 #endif
2718  } else if (PyLong_Check(obj)) {
2719  double v = PyLong_AsDouble(obj);
2720  if (!PyErr_Occurred()) {
2721  if (val) *val = v;
2722  return SWIG_OK;
2723  } else {
2724  PyErr_Clear();
2725  }
2726  }
2727 #ifdef SWIG_PYTHON_CAST_MODE
2728  {
2729  int dispatch = 0;
2730  double d = PyFloat_AsDouble(obj);
2731  if (!PyErr_Occurred()) {
2732  if (val) *val = d;
2733  return SWIG_AddCast(SWIG_OK);
2734  } else {
2735  PyErr_Clear();
2736  }
2737  if (!dispatch) {
2738  long v = PyLong_AsLong(obj);
2739  if (!PyErr_Occurred()) {
2740  if (val) *val = v;
2742  } else {
2743  PyErr_Clear();
2744  }
2745  }
2746  }
2747 #endif
2748  return res;
2749 }
2750 
2751 
2752  #define SWIG_From_double PyFloat_FromDouble
2753 
2754 
2755  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2756  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2757  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2758  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2759  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2761  typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
2762 
2763 
2764 SWIGINTERNINLINE PyObject*
2766 {
2767  return PyInt_FromLong((long) value);
2768 }
2769 
2770 
2771 #include <limits.h>
2772 #if !defined(SWIG_NO_LLONG_MAX)
2773 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2774 # define LLONG_MAX __LONG_LONG_MAX__
2775 # define LLONG_MIN (-LLONG_MAX - 1LL)
2776 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2777 # endif
2778 #endif
2779 
2780 
2781 #include <float.h>
2782 
2783 
2784 #include <math.h>
2785 
2786 
2787 SWIGINTERNINLINE int
2788 SWIG_CanCastAsInteger(double *d, double min, double max) {
2789  double x = *d;
2790  if ((min <= x && x <= max)) {
2791  double fx = floor(x);
2792  double cx = ceil(x);
2793  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2794  if ((errno == EDOM) || (errno == ERANGE)) {
2795  errno = 0;
2796  } else {
2797  double summ, reps, diff;
2798  if (rd < x) {
2799  diff = x - rd;
2800  } else if (rd > x) {
2801  diff = rd - x;
2802  } else {
2803  return 1;
2804  }
2805  summ = rd + x;
2806  reps = diff/summ;
2807  if (reps < 8*DBL_EPSILON) {
2808  *d = rd;
2809  return 1;
2810  }
2811  }
2812  }
2813  return 0;
2814 }
2815 
2816 
2817 SWIGINTERN int
2818 SWIG_AsVal_long (PyObject *obj, long* val)
2819 {
2820 #if PY_VERSION_HEX < 0x03000000
2821  if (PyInt_Check(obj)) {
2822  if (val) *val = PyInt_AsLong(obj);
2823  return SWIG_OK;
2824  } else
2825 #endif
2826  if (PyLong_Check(obj)) {
2827  long v = PyLong_AsLong(obj);
2828  if (!PyErr_Occurred()) {
2829  if (val) *val = v;
2830  return SWIG_OK;
2831  } else {
2832  PyErr_Clear();
2833  return SWIG_OverflowError;
2834  }
2835  }
2836 #ifdef SWIG_PYTHON_CAST_MODE
2837  {
2838  int dispatch = 0;
2839  long v = PyInt_AsLong(obj);
2840  if (!PyErr_Occurred()) {
2841  if (val) *val = v;
2842  return SWIG_AddCast(SWIG_OK);
2843  } else {
2844  PyErr_Clear();
2845  }
2846  if (!dispatch) {
2847  double d;
2848  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2849  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2850  if (val) *val = (long)(d);
2851  return res;
2852  }
2853  }
2854  }
2855 #endif
2856  return SWIG_TypeError;
2857 }
2858 
2859 
2860 SWIGINTERN int
2861 SWIG_AsVal_int (PyObject * obj, int *val)
2862 {
2863  long v;
2864  int res = SWIG_AsVal_long (obj, &v);
2865  if (SWIG_IsOK(res)) {
2866  if ((v < INT_MIN || v > INT_MAX)) {
2867  return SWIG_OverflowError;
2868  } else {
2869  if (val) *val = (int)(v);
2870  }
2871  }
2872  return res;
2873 }
2874 
2875 
2876 SWIGINTERN int
2877 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2878 {
2879 #if PY_VERSION_HEX < 0x03000000
2880  if (PyInt_Check(obj)) {
2881  long v = PyInt_AsLong(obj);
2882  if (v >= 0) {
2883  if (val) *val = v;
2884  return SWIG_OK;
2885  } else {
2886  return SWIG_OverflowError;
2887  }
2888  } else
2889 #endif
2890  if (PyLong_Check(obj)) {
2891  unsigned long v = PyLong_AsUnsignedLong(obj);
2892  if (!PyErr_Occurred()) {
2893  if (val) *val = v;
2894  return SWIG_OK;
2895  } else {
2896  PyErr_Clear();
2897  return SWIG_OverflowError;
2898  }
2899  }
2900 #ifdef SWIG_PYTHON_CAST_MODE
2901  {
2902  int dispatch = 0;
2903  unsigned long v = PyLong_AsUnsignedLong(obj);
2904  if (!PyErr_Occurred()) {
2905  if (val) *val = v;
2906  return SWIG_AddCast(SWIG_OK);
2907  } else {
2908  PyErr_Clear();
2909  }
2910  if (!dispatch) {
2911  double d;
2912  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2913  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2914  if (val) *val = (unsigned long)(d);
2915  return res;
2916  }
2917  }
2918  }
2919 #endif
2920  return SWIG_TypeError;
2921 }
2922 
2923 
2924 SWIGINTERN int
2925 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2926 {
2927  unsigned long v;
2928  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2929  if (SWIG_IsOK(res)) {
2930  if ((v > UINT_MAX)) {
2931  return SWIG_OverflowError;
2932  } else {
2933  if (val) *val = (unsigned int)(v);
2934  }
2935  }
2936  return res;
2937 }
2938 
2939 
2940 SWIGINTERNINLINE PyObject*
2942 {
2943  return PyInt_FromSize_t((size_t) value);
2944 }
2945 
2946 
2949 {
2950  static int init = 0;
2951  static swig_type_info* info = 0;
2952  if (!init) {
2953  info = SWIG_TypeQuery("_p_char");
2954  init = 1;
2955  }
2956  return info;
2957 }
2958 
2959 
2960 SWIGINTERN int
2961 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2962 {
2963 #if PY_VERSION_HEX>=0x03000000
2964 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2965  if (PyBytes_Check(obj))
2966 #else
2967  if (PyUnicode_Check(obj))
2968 #endif
2969 #else
2970  if (PyString_Check(obj))
2971 #endif
2972  {
2973  char *cstr; Py_ssize_t len;
2974  int ret = SWIG_OK;
2975 #if PY_VERSION_HEX>=0x03000000
2976 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2977  if (!alloc && cptr) {
2978  /* We can't allow converting without allocation, since the internal
2979  representation of string in Python 3 is UCS-2/UCS-4 but we require
2980  a UTF-8 representation.
2981  TODO(bhy) More detailed explanation */
2982  return SWIG_RuntimeError;
2983  }
2984  obj = PyUnicode_AsUTF8String(obj);
2985  if (!obj)
2986  return SWIG_TypeError;
2987  if (alloc)
2988  *alloc = SWIG_NEWOBJ;
2989 #endif
2990  PyBytes_AsStringAndSize(obj, &cstr, &len);
2991 #else
2992  PyString_AsStringAndSize(obj, &cstr, &len);
2993 #endif
2994  if (cptr) {
2995  if (alloc) {
2996  if (*alloc == SWIG_NEWOBJ) {
2997  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2998  *alloc = SWIG_NEWOBJ;
2999  } else {
3000  *cptr = cstr;
3001  *alloc = SWIG_OLDOBJ;
3002  }
3003  } else {
3004 #if PY_VERSION_HEX>=0x03000000
3005 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3006  *cptr = PyBytes_AsString(obj);
3007 #else
3008  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3009 #endif
3010 #else
3011  *cptr = SWIG_Python_str_AsChar(obj);
3012  if (!*cptr)
3013  ret = SWIG_TypeError;
3014 #endif
3015  }
3016  }
3017  if (psize) *psize = len + 1;
3018 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3019  Py_XDECREF(obj);
3020 #endif
3021  return ret;
3022  } else {
3023 #if defined(SWIG_PYTHON_2_UNICODE)
3024 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3025 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3026 #endif
3027 #if PY_VERSION_HEX<0x03000000
3028  if (PyUnicode_Check(obj)) {
3029  char *cstr; Py_ssize_t len;
3030  if (!alloc && cptr) {
3031  return SWIG_RuntimeError;
3032  }
3033  obj = PyUnicode_AsUTF8String(obj);
3034  if (!obj)
3035  return SWIG_TypeError;
3036  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3037  if (cptr) {
3038  if (alloc) *alloc = SWIG_NEWOBJ;
3039  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3040  }
3041  if (psize) *psize = len + 1;
3042 
3043  Py_XDECREF(obj);
3044  return SWIG_OK;
3045  } else {
3046  Py_XDECREF(obj);
3047  }
3048  }
3049 #endif
3050 #endif
3051 
3052  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3053  if (pchar_descriptor) {
3054  void* vptr = 0;
3055  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3056  if (cptr) *cptr = (char *) vptr;
3057  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3058  if (alloc) *alloc = SWIG_OLDOBJ;
3059  return SWIG_OK;
3060  }
3061  }
3062  }
3063  return SWIG_TypeError;
3064 }
3065 
3066 
3067 SWIGINTERN int
3068 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3069 {
3070  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3071  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3072  if (SWIG_IsOK(res)) {
3073  /* special case of single char conversion when we don't need space for NUL */
3074  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3075  if (csize <= size) {
3076  if (val) {
3077  if (csize) memcpy(val, cptr, csize*sizeof(char));
3078  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3079  }
3080  if (alloc == SWIG_NEWOBJ) {
3081  free((char*)cptr);
3082  res = SWIG_DelNewMask(res);
3083  }
3084  return res;
3085  }
3086  if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3087  }
3088  return SWIG_TypeError;
3089 }
3090 
3091 
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3094 {
3095  if (carray) {
3096  if (size > INT_MAX) {
3097  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3098  return pchar_descriptor ?
3099  SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3100  } else {
3101 #if PY_VERSION_HEX >= 0x03000000
3102 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3103  return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3104 #else
3105  return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3106 #endif
3107 #else
3108  return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3109 #endif
3110  }
3111  } else {
3112  return SWIG_Py_Void();
3113  }
3114 }
3115 
3116 
3117 SWIGINTERN size_t
3118 SWIG_strnlen(const char* s, size_t maxlen)
3119 {
3120  const char *p;
3121  for (p = s; maxlen-- && *p; p++)
3122  ;
3123  return p - s;
3124 }
3125 
3126 
3127 
3128 
3129 
3130 #define t_output_helper SWIG_Python_AppendOutput
3131 
3132 
3133 SWIGINTERN int
3134 SWIG_AsVal_char (PyObject * obj, char *val)
3135 {
3136  int res = SWIG_AsCharArray(obj, val, 1);
3137  if (!SWIG_IsOK(res)) {
3138  long v;
3139  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3140  if (SWIG_IsOK(res)) {
3141  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3142  if (val) *val = (char)(v);
3143  } else {
3144  res = SWIG_OverflowError;
3145  }
3146  }
3147  }
3148  return res;
3149 }
3150 
3151 #ifdef __cplusplus
3152 extern "C" {
3153 #endif
3154 
3155  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3156 
3157 // some really twisted stuff to allow calling a single precision library from python
3158  PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3159  {
3160  PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3161  mindims, maxdims );
3162  if ( !tmp )
3163  {
3164  // could be an incoming long array which can't be "safely" converted, do it anyway
3165  if ( PyArray_Check( in ) )
3166  {
3167  PyErr_Clear();
3168  tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3169  }
3170  }
3171  return tmp;
3172  }
3173 
3174 
3175 #define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3176 
3177 SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3178  PyObject *resultobj = 0;
3179  PLFLT arg1 ;
3180  PLFLT arg2 ;
3181  PLFLT *arg3 = (PLFLT *) 0 ;
3182  PLFLT *arg4 = (PLFLT *) 0 ;
3183  PLPointer arg5 = (PLPointer) 0 ;
3184  double val1 ;
3185  int ecode1 = 0 ;
3186  double val2 ;
3187  int ecode2 = 0 ;
3188  PLFLT temp3 ;
3189  int res3 = SWIG_TMPOBJ ;
3190  PLFLT temp4 ;
3191  int res4 = SWIG_TMPOBJ ;
3192  PyObject *swig_obj[2] ;
3193 
3194  arg3 = &temp3;
3195  arg4 = &temp4;
3196  {
3197  arg5 = NULL;
3198  }
3199  if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3200  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3201  if (!SWIG_IsOK(ecode1)) {
3202  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3203  }
3204  arg1 = (PLFLT)(val1);
3205  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3206  if (!SWIG_IsOK(ecode2)) {
3207  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3208  }
3209  arg2 = (PLFLT)(val2);
3210  pltr0(arg1,arg2,arg3,arg4,arg5);
3211  resultobj = SWIG_Py_Void();
3212  if (SWIG_IsTmpObj(res3)) {
3213  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3214  } else {
3215  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3216  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3217  }
3218  if (SWIG_IsTmpObj(res4)) {
3219  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3220  } else {
3221  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3222  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3223  }
3224  return resultobj;
3225 fail:
3226  return NULL;
3227 }
3228 
3229 
3230 
3231  PyArrayObject *pltr_xg, *pltr_yg;
3234 
3235  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3236  void cleanup_PLcGrid1( void );
3237  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3238  void cleanup_PLcGrid2( void );
3239 
3240  PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3241  {
3242  // fprintf(stderr, "marshal PLcGrid1\n");
3243  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3244  {
3245  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3246  return NULL;
3247  }
3248  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3249  NPY_PLFLT, 1, 1 );
3250  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3251  NPY_PLFLT, 1, 1 );
3252  if ( pltr_xg == 0 || pltr_yg == 0 )
3253  {
3254  PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3255  return NULL;
3256  }
3257  tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3258  tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3259  if ( isimg == 0 )
3260  {
3261  if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3262  {
3263  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3264  return NULL;
3265  }
3266  }
3267  else
3268  {
3269  if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3270  {
3271  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3272  return NULL;
3273  }
3274  }
3275  tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3276  tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3277  return &tmpGrid1;
3278  }
3279 
3280  void cleanup_PLcGrid1( void )
3281  {
3282  // fprintf(stderr, "cleanup PLcGrid1\n");
3283  Py_CLEAR( pltr_xg );
3284  Py_CLEAR( pltr_yg );
3285  }
3286 
3287  PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3288  {
3289  int i, size;
3290  // fprintf(stderr, "marshal PLcGrid2\n");
3291  if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3292  {
3293  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3294  return NULL;
3295  }
3296  pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3297  NPY_PLFLT, 2, 2 );
3298  pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3299  NPY_PLFLT, 2, 2 );
3300  if ( pltr_xg == 0 || pltr_yg == 0 )
3301  {
3302  PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3303  return NULL;
3304  }
3305  if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3306  PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3307  {
3308  PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3309  return NULL;
3310  }
3311  tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3312  tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3313  if ( isimg == 0 )
3314  {
3315  if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3316  {
3317  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3318  return NULL;
3319  }
3320  }
3321  else
3322  {
3323  if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3324  {
3325  PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3326  return NULL;
3327  }
3328  }
3329  size = tmpGrid2.ny;
3330  tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3331  for ( i = 0; i < tmpGrid2.nx; i++ )
3332  tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3333  tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3334  for ( i = 0; i < tmpGrid2.nx; i++ )
3335  tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3336  return &tmpGrid2;
3337  }
3338 
3339  void cleanup_PLcGrid2( void )
3340  {
3341  // fprintf(stderr, "cleanup PLcGrid2\n");
3342  free( tmpGrid2.xg );
3343  free( tmpGrid2.yg );
3344  Py_CLEAR( pltr_xg );
3345  Py_CLEAR( pltr_yg );
3346  }
3347 
3348 SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3349  PyObject *resultobj = 0;
3350  PLFLT arg1 ;
3351  PLFLT arg2 ;
3352  PLFLT *arg3 = (PLFLT *) 0 ;
3353  PLFLT *arg4 = (PLFLT *) 0 ;
3354  PLcGrid *arg5 = (PLcGrid *) 0 ;
3355  double val1 ;
3356  int ecode1 = 0 ;
3357  double val2 ;
3358  int ecode2 = 0 ;
3359  PLFLT temp3 ;
3360  int res3 = SWIG_TMPOBJ ;
3361  PLFLT temp4 ;
3362  int res4 = SWIG_TMPOBJ ;
3363  PyObject *swig_obj[3] ;
3364 
3365  arg3 = &temp3;
3366  arg4 = &temp4;
3367  if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3368  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3369  if (!SWIG_IsOK(ecode1)) {
3370  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3371  }
3372  arg1 = (PLFLT)(val1);
3373  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3374  if (!SWIG_IsOK(ecode2)) {
3375  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3376  }
3377  arg2 = (PLFLT)(val2);
3378  {
3379  arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3380  if ( !arg5 )
3381  return NULL;
3382  }
3383  pltr1(arg1,arg2,arg3,arg4,arg5);
3384  resultobj = SWIG_Py_Void();
3385  if (SWIG_IsTmpObj(res3)) {
3386  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3387  } else {
3388  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3390  }
3391  if (SWIG_IsTmpObj(res4)) {
3392  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3393  } else {
3394  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3395  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3396  }
3397  {
3398  cleanup_PLcGrid1();
3399  }
3400  return resultobj;
3401 fail:
3402  {
3403  cleanup_PLcGrid1();
3404  }
3405  return NULL;
3406 }
3407 
3408 
3409 SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3410  PyObject *resultobj = 0;
3411  PLFLT arg1 ;
3412  PLFLT arg2 ;
3413  PLFLT *arg3 = (PLFLT *) 0 ;
3414  PLFLT *arg4 = (PLFLT *) 0 ;
3415  PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3416  double val1 ;
3417  int ecode1 = 0 ;
3418  double val2 ;
3419  int ecode2 = 0 ;
3420  PLFLT temp3 ;
3421  int res3 = SWIG_TMPOBJ ;
3422  PLFLT temp4 ;
3423  int res4 = SWIG_TMPOBJ ;
3424  PyObject *swig_obj[3] ;
3425 
3426  arg3 = &temp3;
3427  arg4 = &temp4;
3428  if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3429  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3430  if (!SWIG_IsOK(ecode1)) {
3431  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3432  }
3433  arg1 = (PLFLT)(val1);
3434  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3435  if (!SWIG_IsOK(ecode2)) {
3436  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3437  }
3438  arg2 = (PLFLT)(val2);
3439  {
3440  arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3441  if ( !arg5 )
3442  return NULL;
3443  }
3444  pltr2(arg1,arg2,arg3,arg4,arg5);
3445  resultobj = SWIG_Py_Void();
3446  if (SWIG_IsTmpObj(res3)) {
3447  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3448  } else {
3449  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3450  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3451  }
3452  if (SWIG_IsTmpObj(res4)) {
3453  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3454  } else {
3455  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3456  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3457  }
3458  {
3459  cleanup_PLcGrid2();
3460  }
3461  return resultobj;
3462 fail:
3463  {
3464  cleanup_PLcGrid2();
3465  }
3466  return NULL;
3467 }
3468 
3469 
3470 
3471  // helper code for handling the callback
3472 #if 0
3473  static PyInterpreterState *save_interp = NULL;
3474 #endif
3476  PyObject* python_pltr = NULL;
3477  PyObject* python_f2eval = NULL;
3478  PyObject* python_ct = NULL;
3479  PyObject* python_mapform = NULL;
3480  PyObject* python_label = NULL;
3481 
3482 #if 0
3483 #define MY_BLOCK_THREADS { \
3484  PyThreadState *prev_state, *new_state; \
3485  /* need to have started a thread at some stage */ \
3486  /* for the following to work */ \
3487  PyEval_AcquireLock(); \
3488  new_state = PyThreadState_New( save_interp ); \
3489  prev_state = PyThreadState_Swap( new_state );
3490 #define MY_UNBLOCK_THREADS \
3491  new_state = PyThreadState_Swap( prev_state ); \
3492  PyThreadState_Clear( new_state ); \
3493  PyEval_ReleaseLock(); \
3494  PyThreadState_Delete( new_state ); \
3495  }
3496 #else
3497 #define MY_BLOCK_THREADS
3498 #define MY_UNBLOCK_THREADS
3499 #endif
3500 
3501 // Function prototypes
3502  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3504  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3505  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3506  void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3507  pltr_func marshal_pltr( PyObject* input );
3508  void cleanup_pltr( void );
3509  ct_func marshal_ct( PyObject* input );
3510  void cleanup_ct( void );
3511  mapform_func marshal_mapform( PyObject* input );
3512  void cleanup_mapform( void );
3513  PLPointer marshal_PLPointer( PyObject* input, int isimg );
3514  void cleanup_PLPointer( void );
3515 
3516 
3517 // This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3518 
3519  void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3520  {
3521  PyObject *pdata, *arglist, *result;
3522  PyArrayObject *tmp;
3523 
3524  // the data argument is acutally a pointer to a python object
3525  pdata = (PyObject *) data;
3526  if ( data == NULL )
3527  {
3528  pdata = Py_None;
3529  }
3530  if ( python_pltr ) // if not something is terribly wrong
3531  { // hold a reference to the data object
3532  Py_XINCREF( pdata );
3533  // grab the Global Interpreter Lock to be sure threads don't mess us up
3535  // build the argument list
3536 #ifdef PL_DOUBLE
3537  arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3538 #else
3539  arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3540 #endif
3541  if ( arglist == NULL )
3542  {
3543  fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3544  *tx = *ty = 0;
3545  return;
3546  }
3547  // call the python function
3548  result = PyEval_CallObject( python_pltr, arglist );
3549  // release the argument list
3550  Py_CLEAR( arglist );
3551  // check and unpack the result
3552  if ( result == NULL )
3553  {
3554  fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3555  PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3556  *tx = *ty = 0;
3557  }
3558  else
3559  {
3560  tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3561  if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3562  {
3563  fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3564  PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3565  *tx = *ty = 0;
3566  }
3567  else
3568  {
3569  PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3570  *tx = t[0];
3571  *ty = t[1];
3572  Py_CLEAR( tmp );
3573  }
3574  }
3575  // release the result
3576  Py_CLEAR( result );
3577  // release the global interpreter lock
3579  }
3580  }
3581 
3583  {
3584  PyObject *pdata, *arglist, *result;
3585  PLFLT fresult = 0.0;
3586 
3587  // the data argument is acutally a pointer to a python object
3588  pdata = (PyObject *) data;
3589  if ( python_f2eval ) // if not something is terribly wrong
3590  { // hold a reference to the data object
3591  Py_XINCREF( pdata );
3592  // grab the Global Interpreter Lock to be sure threads don't mess us up
3594  // build the argument list
3595  arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3596  // call the python function
3597  result = PyEval_CallObject( python_f2eval, arglist );
3598  // release the argument list
3599  Py_CLEAR( arglist );
3600  // check and unpack the result
3601  if ( !PyFloat_Check( result ) )
3602  {
3603  fprintf( stderr, "f2eval callback must return a float\n" );
3604  PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3605  }
3606  else
3607  {
3608  // should I test the type here?
3609  fresult = (PLFLT) PyFloat_AsDouble( result );
3610  }
3611  // release the result
3612  Py_CLEAR( result );
3613  // release the global interpreter lock
3615  }
3616  return fresult;
3617  }
3618 
3619  void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3620  {
3621  PyObject *pdata, *arglist, *result, *unicode_string;
3622  char *pystring;
3623 
3624  // the data argument is acutally a pointer to a python object
3625  if ( data )
3626  pdata = (PyObject *) data;
3627  else
3628  pdata = Py_None;
3629  if ( python_label ) // if not something is terribly wrong
3630  { // hold a reference to the data object
3631  Py_XINCREF( pdata );
3632  // grab the Global Interpreter Lock to be sure threads don't mess us up
3634  // build the argument list
3635 #ifdef PL_DOUBLE
3636  arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3637 #else
3638  arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3639 #endif
3640  // call the python function
3641  result = PyEval_CallObject( python_label, arglist );
3642  // release the argument list
3643  //Py_CLEAR(arglist);
3644  // check and unpack the result
3645  if ( result == NULL )
3646  {
3647  fprintf( stderr, "label callback failed with 3 arguments\n" );
3648  PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3649  }
3650  else if ( PyString_Check( result ) )
3651  {
3652  // should I test the type here?
3653  pystring = PyString_AsString( result );
3654  strncpy( string, pystring, len );
3655  }
3656  else if ( PyUnicode_Check( result ) )
3657  {
3658  // unicode_string is never freed? memory leak here?
3659  unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
3660  pystring = PyBytes_AS_STRING( unicode_string );
3661  // len may be different then the byte string length w/ unicode?
3662  strncpy( string, pystring, len );
3663  }
3664  else
3665  {
3666  fprintf( stderr, "label callback must return a string\n" );
3667  PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3668  }
3669  // release the result
3670  Py_CLEAR( result );
3671  // release the global interpreter lock
3673  }
3674  }
3675 
3676  void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3677  {
3678  PyObject *px, *py, *pdata, *arglist, *result;
3679  npy_intp n;
3680  n = 1;
3681 
3682  // the data argument is acutally a pointer to a python object
3683  pdata = (PyObject *) data;
3684  if ( data == NULL )
3685  {
3686  pdata = Py_None;
3687  }
3688  if ( python_ct ) // if not something is terribly wrong
3689  { // hold a reference to the data object
3690  Py_XINCREF( pdata );
3691  // grab the Global Interpreter Lock to be sure threads don't mess us up
3693  // build the argument list
3694  px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3695  py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3696  arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3697  // call the python function
3698  result = PyEval_CallObject( python_ct, arglist );
3699  // release the argument list
3700  Py_CLEAR( arglist );
3701  Py_CLEAR( px );
3702  Py_CLEAR( py );
3703  Py_CLEAR( pdata );
3704  // check and unpack the result
3705  if ( result == NULL )
3706  {
3707  fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3708  PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3709  }
3710  // release the result
3711  Py_CLEAR( result );
3712  // release the global interpreter lock
3714  }
3715  }
3716 
3718  {
3719  PyObject *px, *py, *arglist, *result;
3720  // PyArrayObject *tmpx, *tmpy;
3721 // PLFLT *xx, *yy;
3722 // PLINT i;
3723  npy_intp nn;
3724  nn = n;
3725 
3726  if ( python_mapform ) // if not something is terribly wrong
3727  { // grab the Global Interpreter Lock to be sure threads don't mess us up
3729  // build the argument list
3730 #ifdef PL_HAVE_PTHREAD
3731  px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3732  py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3733 #else
3734  px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3735  py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3736 #endif
3737  arglist = Py_BuildValue( "(iOO)", n, px, py );
3738  // call the python function
3739  result = PyEval_CallObject( python_mapform, arglist );
3740  // release the argument list
3741  Py_CLEAR( arglist );
3742  Py_CLEAR( px );
3743  Py_CLEAR( py );
3744  // check and unpack the result
3745  if ( result == NULL )
3746  {
3747  fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3748  PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3749  }
3750  // release the result
3751  Py_CLEAR( result );
3752  // release the global interpreter lock
3754  }
3755  }
3756 
3757 // marshal the pltr function pointer argument
3758  pltr_func marshal_pltr( PyObject* input )
3759  {
3760  pltr_func result = do_pltr_callback;
3761  PyObject * rep = PyObject_Repr( input );
3762  if ( rep )
3763  {
3764  // Memory leaks here? str and uni_str are not freed?
3765  char* str;
3766  if ( PyUnicode_Check( rep ) )
3767  {
3768  PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
3769  str = PyBytes_AS_STRING( uni_str );
3770  }
3771  else
3772  {
3773  str = PyString_AsString( rep );
3774  }
3775  if ( strstr( str, "function pltr0" ) != 0 )
3776  {
3777  result = pltr0;
3778  pltr_type = CB_0;
3779  python_pltr = NULL;
3780  }
3781  else if ( strstr( str, "function pltr1" ) != 0 )
3782  {
3783  result = pltr1;
3784  pltr_type = CB_1;
3785  python_pltr = NULL;
3786  }
3787  else if ( strstr( str, "function pltr2" ) != 0 )
3788  {
3789  result = pltr2;
3790  pltr_type = CB_2;
3791  python_pltr = NULL;
3792  }
3793  else
3794  {
3795  python_pltr = input;
3796  pltr_type = CB_Python;
3797  Py_XINCREF( input );
3798  }
3799  Py_CLEAR( rep );
3800  }
3801  else
3802  {
3803  python_pltr = input;
3804  pltr_type = CB_Python;
3805  Py_XINCREF( input );
3806  }
3807  return result;
3808  }
3809 
3810  void cleanup_pltr( void )
3811  {
3812  Py_CLEAR( python_pltr );
3813  python_pltr = 0;
3814  }
3815 
3816 // marshal the ct function pointer argument
3817  ct_func marshal_ct( PyObject* input )
3818  {
3819  ct_func result = do_ct_callback;
3820  python_ct = input;
3821  Py_XINCREF( input );
3822  return result;
3823  }
3824 
3825  void cleanup_ct( void )
3826  {
3827  Py_CLEAR( python_ct );
3828  python_ct = 0;
3829  }
3830 
3831 // marshal the mapform function pointer argument
3832  mapform_func marshal_mapform( PyObject* input )
3833  {
3835  python_mapform = input;
3836  Py_XINCREF( input );
3837  return result;
3838  }
3839 
3840  void cleanup_mapform( void )
3841  {
3842  Py_CLEAR( python_mapform );
3843  python_mapform = 0;
3844  }
3845 
3846  PLPointer marshal_PLPointer( PyObject* input, int isimg )
3847  {
3848  PLPointer result = NULL;
3849  switch ( pltr_type )
3850  {
3851  case CB_0:
3852  break;
3853  case CB_1:
3854  if ( input != Py_None )
3855  result = marshal_PLcGrid1( input, isimg );
3856  break;
3857  case CB_2:
3858  if ( input != Py_None )
3859  result = marshal_PLcGrid2( input, isimg );
3860  break;
3861  case CB_Python:
3862  Py_XINCREF( input );
3863  result = (PLPointer *) input;
3864  break;
3865  default:
3866  fprintf( stderr, "pltr_type is invalid\n" );
3867  }
3868  return result;
3869  }
3870 
3871  void cleanup_PLPointer( void )
3872  {
3873  switch ( pltr_type )
3874  {
3875  case CB_0:
3876  break;
3877  case CB_1:
3878  cleanup_PLcGrid1();
3879  break;
3880  case CB_2:
3881  cleanup_PLcGrid2();
3882  break;
3883  case CB_Python:
3884  Py_CLEAR( python_pltr );
3885  break;
3886  default:
3887  fprintf( stderr, "pltr_type is invalid\n" );
3888  }
3889  python_pltr = 0;
3890  pltr_type = CB_0;
3891  }
3892 
3893 
3894 
3895 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3896  PyObject *resultobj = 0;
3897  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3898  int arg2 ;
3899  void *argp1 = 0 ;
3900  int res1 = 0 ;
3901  int val2 ;
3902  int ecode2 = 0 ;
3903  PyObject *swig_obj[2] ;
3904 
3905  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
3906  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3907  if (!SWIG_IsOK(res1)) {
3908  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3909  }
3910  arg1 = (PLGraphicsIn *)(argp1);
3911  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
3912  if (!SWIG_IsOK(ecode2)) {
3913  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
3914  }
3915  arg2 = (int)(val2);
3916  if (arg1) (arg1)->type = arg2;
3917  resultobj = SWIG_Py_Void();
3918  return resultobj;
3919 fail:
3920  return NULL;
3921 }
3922 
3923 
3924 SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3925  PyObject *resultobj = 0;
3926  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3927  void *argp1 = 0 ;
3928  int res1 = 0 ;
3929  PyObject *swig_obj[1] ;
3930  int result;
3931 
3932  if (!args) SWIG_fail;
3933  swig_obj[0] = args;
3934  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3935  if (!SWIG_IsOK(res1)) {
3936  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3937  }
3938  arg1 = (PLGraphicsIn *)(argp1);
3939  result = (int) ((arg1)->type);
3940  resultobj = SWIG_From_int((int)(result));
3941  return resultobj;
3942 fail:
3943  return NULL;
3944 }
3945 
3946 
3947 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3948  PyObject *resultobj = 0;
3949  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3950  unsigned int arg2 ;
3951  void *argp1 = 0 ;
3952  int res1 = 0 ;
3953  unsigned int val2 ;
3954  int ecode2 = 0 ;
3955  PyObject *swig_obj[2] ;
3956 
3957  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
3958  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3959  if (!SWIG_IsOK(res1)) {
3960  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3961  }
3962  arg1 = (PLGraphicsIn *)(argp1);
3963  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
3964  if (!SWIG_IsOK(ecode2)) {
3965  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
3966  }
3967  arg2 = (unsigned int)(val2);
3968  if (arg1) (arg1)->state = arg2;
3969  resultobj = SWIG_Py_Void();
3970  return resultobj;
3971 fail:
3972  return NULL;
3973 }
3974 
3975 
3976 SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3977  PyObject *resultobj = 0;
3978  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3979  void *argp1 = 0 ;
3980  int res1 = 0 ;
3981  PyObject *swig_obj[1] ;
3982  unsigned int result;
3983 
3984  if (!args) SWIG_fail;
3985  swig_obj[0] = args;
3986  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3987  if (!SWIG_IsOK(res1)) {
3988  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3989  }
3990  arg1 = (PLGraphicsIn *)(argp1);
3991  result = (unsigned int) ((arg1)->state);
3992  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
3993  return resultobj;
3994 fail:
3995  return NULL;
3996 }
3997 
3998 
3999 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4000  PyObject *resultobj = 0;
4001  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4002  unsigned int arg2 ;
4003  void *argp1 = 0 ;
4004  int res1 = 0 ;
4005  unsigned int val2 ;
4006  int ecode2 = 0 ;
4007  PyObject *swig_obj[2] ;
4008 
4009  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4010  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4011  if (!SWIG_IsOK(res1)) {
4012  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4013  }
4014  arg1 = (PLGraphicsIn *)(argp1);
4015  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4016  if (!SWIG_IsOK(ecode2)) {
4017  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4018  }
4019  arg2 = (unsigned int)(val2);
4020  if (arg1) (arg1)->keysym = arg2;
4021  resultobj = SWIG_Py_Void();
4022  return resultobj;
4023 fail:
4024  return NULL;
4025 }
4026 
4027 
4028 SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4029  PyObject *resultobj = 0;
4030  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4031  void *argp1 = 0 ;
4032  int res1 = 0 ;
4033  PyObject *swig_obj[1] ;
4034  unsigned int result;
4035 
4036  if (!args) SWIG_fail;
4037  swig_obj[0] = args;
4038  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4039  if (!SWIG_IsOK(res1)) {
4040  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4041  }
4042  arg1 = (PLGraphicsIn *)(argp1);
4043  result = (unsigned int) ((arg1)->keysym);
4044  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4045  return resultobj;
4046 fail:
4047  return NULL;
4048 }
4049 
4050 
4051 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4052  PyObject *resultobj = 0;
4053  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4054  unsigned int arg2 ;
4055  void *argp1 = 0 ;
4056  int res1 = 0 ;
4057  unsigned int val2 ;
4058  int ecode2 = 0 ;
4059  PyObject *swig_obj[2] ;
4060 
4061  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4062  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4063  if (!SWIG_IsOK(res1)) {
4064  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4065  }
4066  arg1 = (PLGraphicsIn *)(argp1);
4067  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4068  if (!SWIG_IsOK(ecode2)) {
4069  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4070  }
4071  arg2 = (unsigned int)(val2);
4072  if (arg1) (arg1)->button = arg2;
4073  resultobj = SWIG_Py_Void();
4074  return resultobj;
4075 fail:
4076  return NULL;
4077 }
4078 
4079 
4080 SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4081  PyObject *resultobj = 0;
4082  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4083  void *argp1 = 0 ;
4084  int res1 = 0 ;
4085  PyObject *swig_obj[1] ;
4086  unsigned int result;
4087 
4088  if (!args) SWIG_fail;
4089  swig_obj[0] = args;
4090  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4091  if (!SWIG_IsOK(res1)) {
4092  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4093  }
4094  arg1 = (PLGraphicsIn *)(argp1);
4095  result = (unsigned int) ((arg1)->button);
4096  resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4097  return resultobj;
4098 fail:
4099  return NULL;
4100 }
4101 
4102 
4103 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4104  PyObject *resultobj = 0;
4105  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4106  PLINT arg2 ;
4107  void *argp1 = 0 ;
4108  int res1 = 0 ;
4109  int val2 ;
4110  int ecode2 = 0 ;
4111  PyObject *swig_obj[2] ;
4112 
4113  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4114  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4115  if (!SWIG_IsOK(res1)) {
4116  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4117  }
4118  arg1 = (PLGraphicsIn *)(argp1);
4119  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4120  if (!SWIG_IsOK(ecode2)) {
4121  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4122  }
4123  arg2 = (PLINT)(val2);
4124  if (arg1) (arg1)->subwindow = arg2;
4125  resultobj = SWIG_Py_Void();
4126  return resultobj;
4127 fail:
4128  return NULL;
4129 }
4130 
4131 
4132 SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4133  PyObject *resultobj = 0;
4134  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4135  void *argp1 = 0 ;
4136  int res1 = 0 ;
4137  PyObject *swig_obj[1] ;
4138  PLINT result;
4139 
4140  if (!args) SWIG_fail;
4141  swig_obj[0] = args;
4142  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4143  if (!SWIG_IsOK(res1)) {
4144  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4145  }
4146  arg1 = (PLGraphicsIn *)(argp1);
4147  result = (PLINT) ((arg1)->subwindow);
4148  resultobj = SWIG_From_int((int)(result));
4149  return resultobj;
4150 fail:
4151  return NULL;
4152 }
4153 
4154 
4155 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4156  PyObject *resultobj = 0;
4157  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4158  char *arg2 ;
4159  void *argp1 = 0 ;
4160  int res1 = 0 ;
4161  char temp2[16] ;
4162  int res2 ;
4163  PyObject *swig_obj[2] ;
4164 
4165  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4166  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4167  if (!SWIG_IsOK(res1)) {
4168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4169  }
4170  arg1 = (PLGraphicsIn *)(argp1);
4171  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4172  if (!SWIG_IsOK(res2)) {
4173  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4174  }
4175  arg2 = (char *)(temp2);
4176  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4177  else memset(arg1->string,0,16*sizeof(char));
4178  resultobj = SWIG_Py_Void();
4179  return resultobj;
4180 fail:
4181  return NULL;
4182 }
4183 
4184 
4185 SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4186  PyObject *resultobj = 0;
4187  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4188  void *argp1 = 0 ;
4189  int res1 = 0 ;
4190  PyObject *swig_obj[1] ;
4191  char *result = 0 ;
4192 
4193  if (!args) SWIG_fail;
4194  swig_obj[0] = args;
4195  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4196  if (!SWIG_IsOK(res1)) {
4197  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4198  }
4199  arg1 = (PLGraphicsIn *)(argp1);
4200  result = (char *)(char *) ((arg1)->string);
4201  {
4202  size_t size = SWIG_strnlen(result, 16);
4203 
4204 
4205 
4206  resultobj = SWIG_FromCharPtrAndSize(result, size);
4207  }
4208  return resultobj;
4209 fail:
4210  return NULL;
4211 }
4212 
4213 
4214 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4215  PyObject *resultobj = 0;
4216  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4217  int arg2 ;
4218  void *argp1 = 0 ;
4219  int res1 = 0 ;
4220  int val2 ;
4221  int ecode2 = 0 ;
4222  PyObject *swig_obj[2] ;
4223 
4224  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4225  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4226  if (!SWIG_IsOK(res1)) {
4227  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4228  }
4229  arg1 = (PLGraphicsIn *)(argp1);
4230  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4231  if (!SWIG_IsOK(ecode2)) {
4232  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4233  }
4234  arg2 = (int)(val2);
4235  if (arg1) (arg1)->pX = arg2;
4236  resultobj = SWIG_Py_Void();
4237  return resultobj;
4238 fail:
4239  return NULL;
4240 }
4241 
4242 
4243 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4244  PyObject *resultobj = 0;
4245  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4246  void *argp1 = 0 ;
4247  int res1 = 0 ;
4248  PyObject *swig_obj[1] ;
4249  int result;
4250 
4251  if (!args) SWIG_fail;
4252  swig_obj[0] = args;
4253  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4254  if (!SWIG_IsOK(res1)) {
4255  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4256  }
4257  arg1 = (PLGraphicsIn *)(argp1);
4258  result = (int) ((arg1)->pX);
4259  resultobj = SWIG_From_int((int)(result));
4260  return resultobj;
4261 fail:
4262  return NULL;
4263 }
4264 
4265 
4266 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4267  PyObject *resultobj = 0;
4268  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4269  int arg2 ;
4270  void *argp1 = 0 ;
4271  int res1 = 0 ;
4272  int val2 ;
4273  int ecode2 = 0 ;
4274  PyObject *swig_obj[2] ;
4275 
4276  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4277  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4278  if (!SWIG_IsOK(res1)) {
4279  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4280  }
4281  arg1 = (PLGraphicsIn *)(argp1);
4282  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4283  if (!SWIG_IsOK(ecode2)) {
4284  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4285  }
4286  arg2 = (int)(val2);
4287  if (arg1) (arg1)->pY = arg2;
4288  resultobj = SWIG_Py_Void();
4289  return resultobj;
4290 fail:
4291  return NULL;
4292 }
4293 
4294 
4295 SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4296  PyObject *resultobj = 0;
4297  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4298  void *argp1 = 0 ;
4299  int res1 = 0 ;
4300  PyObject *swig_obj[1] ;
4301  int result;
4302 
4303  if (!args) SWIG_fail;
4304  swig_obj[0] = args;
4305  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4306  if (!SWIG_IsOK(res1)) {
4307  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4308  }
4309  arg1 = (PLGraphicsIn *)(argp1);
4310  result = (int) ((arg1)->pY);
4311  resultobj = SWIG_From_int((int)(result));
4312  return resultobj;
4313 fail:
4314  return NULL;
4315 }
4316 
4317 
4318 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4319  PyObject *resultobj = 0;
4320  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4321  PLFLT arg2 ;
4322  void *argp1 = 0 ;
4323  int res1 = 0 ;
4324  double val2 ;
4325  int ecode2 = 0 ;
4326  PyObject *swig_obj[2] ;
4327 
4328  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4329  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4330  if (!SWIG_IsOK(res1)) {
4331  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4332  }
4333  arg1 = (PLGraphicsIn *)(argp1);
4334  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4335  if (!SWIG_IsOK(ecode2)) {
4336  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4337  }
4338  arg2 = (PLFLT)(val2);
4339  if (arg1) (arg1)->dX = arg2;
4340  resultobj = SWIG_Py_Void();
4341  return resultobj;
4342 fail:
4343  return NULL;
4344 }
4345 
4346 
4347 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4348  PyObject *resultobj = 0;
4349  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4350  void *argp1 = 0 ;
4351  int res1 = 0 ;
4352  PyObject *swig_obj[1] ;
4353  PLFLT result;
4354 
4355  if (!args) SWIG_fail;
4356  swig_obj[0] = args;
4357  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4358  if (!SWIG_IsOK(res1)) {
4359  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4360  }
4361  arg1 = (PLGraphicsIn *)(argp1);
4362  result = (PLFLT) ((arg1)->dX);
4363  resultobj = SWIG_From_double((double)(result));
4364  return resultobj;
4365 fail:
4366  return NULL;
4367 }
4368 
4369 
4370 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4371  PyObject *resultobj = 0;
4372  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4373  PLFLT arg2 ;
4374  void *argp1 = 0 ;
4375  int res1 = 0 ;
4376  double val2 ;
4377  int ecode2 = 0 ;
4378  PyObject *swig_obj[2] ;
4379 
4380  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4381  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4382  if (!SWIG_IsOK(res1)) {
4383  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4384  }
4385  arg1 = (PLGraphicsIn *)(argp1);
4386  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4387  if (!SWIG_IsOK(ecode2)) {
4388  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4389  }
4390  arg2 = (PLFLT)(val2);
4391  if (arg1) (arg1)->dY = arg2;
4392  resultobj = SWIG_Py_Void();
4393  return resultobj;
4394 fail:
4395  return NULL;
4396 }
4397 
4398 
4399 SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400  PyObject *resultobj = 0;
4401  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4402  void *argp1 = 0 ;
4403  int res1 = 0 ;
4404  PyObject *swig_obj[1] ;
4405  PLFLT result;
4406 
4407  if (!args) SWIG_fail;
4408  swig_obj[0] = args;
4409  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4410  if (!SWIG_IsOK(res1)) {
4411  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4412  }
4413  arg1 = (PLGraphicsIn *)(argp1);
4414  result = (PLFLT) ((arg1)->dY);
4415  resultobj = SWIG_From_double((double)(result));
4416  return resultobj;
4417 fail:
4418  return NULL;
4419 }
4420 
4421 
4422 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4423  PyObject *resultobj = 0;
4424  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4425  PLFLT arg2 ;
4426  void *argp1 = 0 ;
4427  int res1 = 0 ;
4428  double val2 ;
4429  int ecode2 = 0 ;
4430  PyObject *swig_obj[2] ;
4431 
4432  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4433  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4434  if (!SWIG_IsOK(res1)) {
4435  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4436  }
4437  arg1 = (PLGraphicsIn *)(argp1);
4438  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4439  if (!SWIG_IsOK(ecode2)) {
4440  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4441  }
4442  arg2 = (PLFLT)(val2);
4443  if (arg1) (arg1)->wX = arg2;
4444  resultobj = SWIG_Py_Void();
4445  return resultobj;
4446 fail:
4447  return NULL;
4448 }
4449 
4450 
4451 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4452  PyObject *resultobj = 0;
4453  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4454  void *argp1 = 0 ;
4455  int res1 = 0 ;
4456  PyObject *swig_obj[1] ;
4457  PLFLT result;
4458 
4459  if (!args) SWIG_fail;
4460  swig_obj[0] = args;
4461  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4462  if (!SWIG_IsOK(res1)) {
4463  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4464  }
4465  arg1 = (PLGraphicsIn *)(argp1);
4466  result = (PLFLT) ((arg1)->wX);
4467  resultobj = SWIG_From_double((double)(result));
4468  return resultobj;
4469 fail:
4470  return NULL;
4471 }
4472 
4473 
4474 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475  PyObject *resultobj = 0;
4476  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4477  PLFLT arg2 ;
4478  void *argp1 = 0 ;
4479  int res1 = 0 ;
4480  double val2 ;
4481  int ecode2 = 0 ;
4482  PyObject *swig_obj[2] ;
4483 
4484  if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
4485  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4486  if (!SWIG_IsOK(res1)) {
4487  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4488  }
4489  arg1 = (PLGraphicsIn *)(argp1);
4490  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4491  if (!SWIG_IsOK(ecode2)) {
4492  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4493  }
4494  arg2 = (PLFLT)(val2);
4495  if (arg1) (arg1)->wY = arg2;
4496  resultobj = SWIG_Py_Void();
4497  return resultobj;
4498 fail:
4499  return NULL;
4500 }
4501 
4502 
4503 SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4504  PyObject *resultobj = 0;
4505  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4506  void *argp1 = 0 ;
4507  int res1 = 0 ;
4508  PyObject *swig_obj[1] ;
4509  PLFLT result;
4510 
4511  if (!args) SWIG_fail;
4512  swig_obj[0] = args;
4513  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4514  if (!SWIG_IsOK(res1)) {
4515  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4516  }
4517  arg1 = (PLGraphicsIn *)(argp1);
4518  result = (PLFLT) ((arg1)->wY);
4519  resultobj = SWIG_From_double((double)(result));
4520  return resultobj;
4521 fail:
4522  return NULL;
4523 }
4524 
4525 
4526 SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4527  PyObject *resultobj = 0;
4528  PLGraphicsIn *result = 0 ;
4529 
4530  if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
4531  result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4533  return resultobj;
4534 fail:
4535  return NULL;
4536 }
4537 
4538 
4539 SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4540  PyObject *resultobj = 0;
4541  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4542  void *argp1 = 0 ;
4543  int res1 = 0 ;
4544  PyObject *swig_obj[1] ;
4545 
4546  if (!args) SWIG_fail;
4547  swig_obj[0] = args;
4548  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4549  if (!SWIG_IsOK(res1)) {
4550  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4551  }
4552  arg1 = (PLGraphicsIn *)(argp1);
4553  free((char *) arg1);
4554  resultobj = SWIG_Py_Void();
4555  return resultobj;
4556 fail:
4557  return NULL;
4558 }
4559 
4560 
4561 SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4562  PyObject *obj;
4563  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
4565  return SWIG_Py_Void();
4566 }
4567 
4568 SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4569  return SWIG_Python_InitShadowInstance(args);
4570 }
4571 
4572 SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573  PyObject *resultobj = 0;
4574  PLINT arg1 ;
4575  int val1 ;
4576  int ecode1 = 0 ;
4577  PyObject *swig_obj[1] ;
4578 
4579  if (!args) SWIG_fail;
4580  swig_obj[0] = args;
4581  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4582  if (!SWIG_IsOK(ecode1)) {
4583  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4584  }
4585  arg1 = (PLINT)(val1);
4586  plsxwin(arg1);
4587  resultobj = SWIG_Py_Void();
4588  return resultobj;
4589 fail:
4590  return NULL;
4591 }
4592 
4593 
4594 SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595  PyObject *resultobj = 0;
4596  PLINT arg1 ;
4597  PLINT arg2 ;
4598  int val1 ;
4599  int ecode1 = 0 ;
4600  int val2 ;
4601  int ecode2 = 0 ;
4602  PyObject *swig_obj[2] ;
4603 
4604  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
4605  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4606  if (!SWIG_IsOK(ecode1)) {
4607  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4608  }
4609  arg1 = (PLINT)(val1);
4610  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4611  if (!SWIG_IsOK(ecode2)) {
4612  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4613  }
4614  arg2 = (PLINT)(val2);
4615  pl_setcontlabelformat(arg1,arg2);
4616  resultobj = SWIG_Py_Void();
4617  return resultobj;
4618 fail:
4619  return NULL;
4620 }
4621 
4622 
4623 SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4624  PyObject *resultobj = 0;
4625  PLFLT arg1 ;
4626  PLFLT arg2 ;
4627  PLFLT arg3 ;
4628  PLINT arg4 ;
4629  double val1 ;
4630  int ecode1 = 0 ;
4631  double val2 ;
4632  int ecode2 = 0 ;
4633  double val3 ;
4634  int ecode3 = 0 ;
4635  int val4 ;
4636  int ecode4 = 0 ;
4637  PyObject *swig_obj[4] ;
4638 
4639  if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
4640  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4641  if (!SWIG_IsOK(ecode1)) {
4642  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4643  }
4644  arg1 = (PLFLT)(val1);
4645  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4646  if (!SWIG_IsOK(ecode2)) {
4647  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4648  }
4649  arg2 = (PLFLT)(val2);
4650  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4651  if (!SWIG_IsOK(ecode3)) {
4652  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4653  }
4654  arg3 = (PLFLT)(val3);
4655  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
4656  if (!SWIG_IsOK(ecode4)) {
4657  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4658  }
4659  arg4 = (PLINT)(val4);
4660  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4661  resultobj = SWIG_Py_Void();
4662  return resultobj;
4663 fail:
4664  return NULL;
4665 }
4666 
4667 
4668 SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4669  PyObject *resultobj = 0;
4670  PLINT arg1 ;
4671  int val1 ;
4672  int ecode1 = 0 ;
4673  PyObject *swig_obj[1] ;
4674 
4675  if (!args) SWIG_fail;
4676  swig_obj[0] = args;
4677  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4678  if (!SWIG_IsOK(ecode1)) {
4679  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4680  }
4681  arg1 = (PLINT)(val1);
4682  pladv(arg1);
4683  resultobj = SWIG_Py_Void();
4684  return resultobj;
4685 fail:
4686  return NULL;
4687 }
4688 
4689 
4690 SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4691  PyObject *resultobj = 0;
4692  PLFLT arg1 ;
4693  PLFLT arg2 ;
4694  PLFLT arg3 ;
4695  PLFLT arg4 ;
4696  PLFLT arg5 ;
4697  PLFLT arg6 ;
4698  PLFLT arg7 ;
4699  PLBOOL arg8 ;
4700  double val1 ;
4701  int ecode1 = 0 ;
4702  double val2 ;
4703  int ecode2 = 0 ;
4704  double val3 ;
4705  int ecode3 = 0 ;
4706  double val4 ;
4707  int ecode4 = 0 ;
4708  double val5 ;
4709  int ecode5 = 0 ;
4710  double val6 ;
4711  int ecode6 = 0 ;
4712  double val7 ;
4713  int ecode7 = 0 ;
4714  int val8 ;
4715  int ecode8 = 0 ;
4716  PyObject *swig_obj[8] ;
4717 
4718  if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
4719  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4720  if (!SWIG_IsOK(ecode1)) {
4721  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4722  }
4723  arg1 = (PLFLT)(val1);
4724  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4725  if (!SWIG_IsOK(ecode2)) {
4726  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4727  }
4728  arg2 = (PLFLT)(val2);
4729  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4730  if (!SWIG_IsOK(ecode3)) {
4731  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4732  }
4733  arg3 = (PLFLT)(val3);
4734  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4735  if (!SWIG_IsOK(ecode4)) {
4736  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4737  }
4738  arg4 = (PLFLT)(val4);
4739  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
4740  if (!SWIG_IsOK(ecode5)) {
4741  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4742  }
4743  arg5 = (PLFLT)(val5);
4744  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
4745  if (!SWIG_IsOK(ecode6)) {
4746  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4747  }
4748  arg6 = (PLFLT)(val6);
4749  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4750  if (!SWIG_IsOK(ecode7)) {
4751  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4752  }
4753  arg7 = (PLFLT)(val7);
4754  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4755  if (!SWIG_IsOK(ecode8)) {
4756  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4757  }
4758  arg8 = (PLBOOL)(val8);
4759  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4760  resultobj = SWIG_Py_Void();
4761  return resultobj;
4762 fail:
4763  return NULL;
4764 }
4765 
4766 
4767 SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4768  PyObject *resultobj = 0;
4769  PLFLT arg1 ;
4770  PLFLT arg2 ;
4771  char *arg3 = (char *) 0 ;
4772  PLFLT arg4 ;
4773  PLINT arg5 ;
4774  char *arg6 = (char *) 0 ;
4775  PLFLT arg7 ;
4776  PLINT arg8 ;
4777  double val1 ;
4778  int ecode1 = 0 ;
4779  double val2 ;
4780  int ecode2 = 0 ;
4781  int res3 ;
4782  char *buf3 = 0 ;
4783  int alloc3 = 0 ;
4784  double val4 ;
4785  int ecode4 = 0 ;
4786  int val5 ;
4787  int ecode5 = 0 ;
4788  int res6 ;
4789  char *buf6 = 0 ;
4790  int alloc6 = 0 ;
4791  double val7 ;
4792  int ecode7 = 0 ;
4793  int val8 ;
4794  int ecode8 = 0 ;
4795  PyObject *swig_obj[8] ;
4796 
4797  if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
4798  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4799  if (!SWIG_IsOK(ecode1)) {
4800  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
4801  }
4802  arg1 = (PLFLT)(val1);
4803  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4804  if (!SWIG_IsOK(ecode2)) {
4805  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
4806  }
4807  arg2 = (PLFLT)(val2);
4808  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
4809  if (!SWIG_IsOK(res3)) {
4810  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
4811  }
4812  arg3 = (char *)(buf3);
4813  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4814  if (!SWIG_IsOK(ecode4)) {
4815  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
4816  }
4817  arg4 = (PLFLT)(val4);
4818  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
4819  if (!SWIG_IsOK(ecode5)) {
4820  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
4821  }
4822  arg5 = (PLINT)(val5);
4823  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
4824  if (!SWIG_IsOK(res6)) {
4825  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
4826  }
4827  arg6 = (char *)(buf6);
4828  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4829  if (!SWIG_IsOK(ecode7)) {
4830  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
4831  }
4832  arg7 = (PLFLT)(val7);
4833  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4834  if (!SWIG_IsOK(ecode8)) {
4835  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
4836  }
4837  arg8 = (PLINT)(val8);
4838  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4839  resultobj = SWIG_Py_Void();
4840  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4841  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4842  return resultobj;
4843 fail:
4844  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4845  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4846  return NULL;
4847 }
4848 
4849 
4850 SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4851  PyObject *resultobj = 0;
4852  PLINT arg1 ;
4853  PLFLT *arg2 = (PLFLT *) 0 ;
4854  PLFLT *arg3 = (PLFLT *) 0 ;
4855  PLINT arg4 ;
4856  PyArrayObject *tmp1 = NULL ;
4857  PyArrayObject *tmp3 = NULL ;
4858  int val4 ;
4859  int ecode4 = 0 ;
4860  PyObject *swig_obj[3] ;
4861 
4862  if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
4863  {
4864  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
4865  if ( tmp1 == NULL )
4866  return NULL;
4867  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
4868  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
4869  }
4870  {
4871  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
4872  if ( tmp3 == NULL )
4873  return NULL;
4874  if ( PyArray_DIMS( tmp3 )[0] != Alen )
4875  {
4876  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
4877  return NULL;
4878  }
4879  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
4880  }
4881  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
4882  if (!SWIG_IsOK(ecode4)) {
4883  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
4884  }
4885  arg4 = (PLINT)(val4);
4886  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4887  resultobj = SWIG_Py_Void();
4888  {
4889  Py_CLEAR( tmp1 );
4890  }
4891  {
4892  Py_CLEAR( tmp3 );
4893  }
4894  return resultobj;
4895 fail:
4896  {
4897  Py_CLEAR( tmp1 );
4898  }
4899  {
4900  Py_CLEAR( tmp3 );
4901  }
4902  return NULL;
4903 }
4904 
4905 
4906 SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4907  PyObject *resultobj = 0;
4908  PLINT *arg1 = (PLINT *) 0 ;
4909  PLINT *arg2 = (PLINT *) 0 ;
4910  PLINT *arg3 = (PLINT *) 0 ;
4911  PLINT *arg4 = (PLINT *) 0 ;
4912  PLINT *arg5 = (PLINT *) 0 ;
4913  PLFLT *arg6 = (PLFLT *) 0 ;
4914  PLFLT arg7 ;
4915  PLINT temp1 ;
4916  int res1 = SWIG_TMPOBJ ;
4917  PLINT temp2 ;
4918  int res2 = SWIG_TMPOBJ ;
4919  PLINT temp3 ;
4920  int res3 = SWIG_TMPOBJ ;
4921  PLINT temp4 ;
4922  int res4 = SWIG_TMPOBJ ;
4923  PLINT temp5 ;
4924  int res5 = SWIG_TMPOBJ ;
4925  PLFLT temp6 ;
4926  int res6 = SWIG_TMPOBJ ;
4927  double val7 ;
4928  int ecode7 = 0 ;
4929  PyObject *swig_obj[1] ;
4930 
4931  arg1 = &temp1;
4932  arg2 = &temp2;
4933  arg3 = &temp3;
4934  arg4 = &temp4;
4935  arg5 = &temp5;
4936  arg6 = &temp6;
4937  if (!args) SWIG_fail;
4938  swig_obj[0] = args;
4939  ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
4940  if (!SWIG_IsOK(ecode7)) {
4941  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
4942  }
4943  arg7 = (PLFLT)(val7);
4944  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4945  resultobj = SWIG_Py_Void();
4946  if (SWIG_IsTmpObj(res1)) {
4947  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
4948  } else {
4949  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4950  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
4951  }
4952  if (SWIG_IsTmpObj(res2)) {
4953  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
4954  } else {
4955  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4956  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
4957  }
4958  if (SWIG_IsTmpObj(res3)) {
4959  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
4960  } else {
4961  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4962  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
4963  }
4964  if (SWIG_IsTmpObj(res4)) {
4965  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
4966  } else {
4967  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4968  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
4969  }
4970  if (SWIG_IsTmpObj(res5)) {
4971  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
4972  } else {
4973  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4974  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
4975  }
4976  if (SWIG_IsTmpObj(res6)) {
4977  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
4978  } else {
4979  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4980  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
4981  }
4982  return resultobj;
4983 fail:
4984  return NULL;
4985 }
4986 
4987 
4988 SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4989  PyObject *resultobj = 0;
4990 
4991  if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
4992  plbop();
4993  resultobj = SWIG_Py_Void();
4994  return resultobj;
4995 fail:
4996  return NULL;
4997 }
4998 
4999 
5000 SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001  PyObject *resultobj = 0;
5002  char *arg1 = (char *) 0 ;
5003  PLFLT arg2 ;
5004  PLINT arg3 ;
5005  char *arg4 = (char *) 0 ;
5006  PLFLT arg5 ;
5007  PLINT arg6 ;
5008  int res1 ;
5009  char *buf1 = 0 ;
5010  int alloc1 = 0 ;
5011  double val2 ;
5012  int ecode2 = 0 ;
5013  int val3 ;
5014  int ecode3 = 0 ;
5015  int res4 ;
5016  char *buf4 = 0 ;
5017  int alloc4 = 0 ;
5018  double val5 ;
5019  int ecode5 = 0 ;
5020  int val6 ;
5021  int ecode6 = 0 ;
5022  PyObject *swig_obj[6] ;
5023 
5024  if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5025  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5026  if (!SWIG_IsOK(res1)) {
5027  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5028  }
5029  arg1 = (char *)(buf1);
5030  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5031  if (!SWIG_IsOK(ecode2)) {
5032  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5033  }
5034  arg2 = (PLFLT)(val2);
5035  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5036  if (!SWIG_IsOK(ecode3)) {
5037  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5038  }
5039  arg3 = (PLINT)(val3);
5040  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5041  if (!SWIG_IsOK(res4)) {
5042  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5043  }
5044  arg4 = (char *)(buf4);
5045  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5046  if (!SWIG_IsOK(ecode5)) {
5047  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5048  }
5049  arg5 = (PLFLT)(val5);
5050  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5051  if (!SWIG_IsOK(ecode6)) {
5052  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5053  }
5054  arg6 = (PLINT)(val6);
5055  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5056  resultobj = SWIG_Py_Void();
5057  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5058  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5059  return resultobj;
5060 fail:
5061  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5062  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5063  return NULL;
5064 }
5065 
5066 
5067 SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068  PyObject *resultobj = 0;
5069  char *arg1 = (char *) 0 ;
5070  char *arg2 = (char *) 0 ;
5071  PLFLT arg3 ;
5072  PLINT arg4 ;
5073  char *arg5 = (char *) 0 ;
5074  char *arg6 = (char *) 0 ;
5075  PLFLT arg7 ;
5076  PLINT arg8 ;
5077  char *arg9 = (char *) 0 ;
5078  char *arg10 = (char *) 0 ;
5079  PLFLT arg11 ;
5080  PLINT arg12 ;
5081  int res1 ;
5082  char *buf1 = 0 ;
5083  int alloc1 = 0 ;
5084  int res2 ;
5085  char *buf2 = 0 ;
5086  int alloc2 = 0 ;
5087  double val3 ;
5088  int ecode3 = 0 ;
5089  int val4 ;
5090  int ecode4 = 0 ;
5091  int res5 ;
5092  char *buf5 = 0 ;
5093  int alloc5 = 0 ;
5094  int res6 ;
5095  char *buf6 = 0 ;
5096  int alloc6 = 0 ;
5097  double val7 ;
5098  int ecode7 = 0 ;
5099  int val8 ;
5100  int ecode8 = 0 ;
5101  int res9 ;
5102  char *buf9 = 0 ;
5103  int alloc9 = 0 ;
5104  int res10 ;
5105  char *buf10 = 0 ;
5106  int alloc10 = 0 ;
5107  double val11 ;
5108  int ecode11 = 0 ;
5109  int val12 ;
5110  int ecode12 = 0 ;
5111  PyObject *swig_obj[12] ;
5112 
5113  if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5114  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5115  if (!SWIG_IsOK(res1)) {
5116  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5117  }
5118  arg1 = (char *)(buf1);
5119  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5120  if (!SWIG_IsOK(res2)) {
5121  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5122  }
5123  arg2 = (char *)(buf2);
5124  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5125  if (!SWIG_IsOK(ecode3)) {
5126  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5127  }
5128  arg3 = (PLFLT)(val3);
5129  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5130  if (!SWIG_IsOK(ecode4)) {
5131  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5132  }
5133  arg4 = (PLINT)(val4);
5134  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5135  if (!SWIG_IsOK(res5)) {
5136  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5137  }
5138  arg5 = (char *)(buf5);
5139  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5140  if (!SWIG_IsOK(res6)) {
5141  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5142  }
5143  arg6 = (char *)(buf6);
5144  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5145  if (!SWIG_IsOK(ecode7)) {
5146  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5147  }
5148  arg7 = (PLFLT)(val7);
5149  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5150  if (!SWIG_IsOK(ecode8)) {
5151  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5152  }
5153  arg8 = (PLINT)(val8);
5154  res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5155  if (!SWIG_IsOK(res9)) {
5156  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5157  }
5158  arg9 = (char *)(buf9);
5159  res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5160  if (!SWIG_IsOK(res10)) {
5161  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5162  }
5163  arg10 = (char *)(buf10);
5164  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5165  if (!SWIG_IsOK(ecode11)) {
5166  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5167  }
5168  arg11 = (PLFLT)(val11);
5169  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5170  if (!SWIG_IsOK(ecode12)) {
5171  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5172  }
5173  arg12 = (PLINT)(val12);
5174  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);
5175  resultobj = SWIG_Py_Void();
5176  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5177  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5178  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5179  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5180  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5181  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5182  return resultobj;
5183 fail:
5184  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5185  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5186  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5187  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5188  if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5189  if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5190  return NULL;
5191 }
5192 
5193 
5194 SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5195  PyObject *resultobj = 0;
5196  PLFLT arg1 ;
5197  PLFLT arg2 ;
5198  PLFLT *arg3 = (PLFLT *) 0 ;
5199  PLFLT *arg4 = (PLFLT *) 0 ;
5200  PLINT *arg5 = (PLINT *) 0 ;
5201  double val1 ;
5202  int ecode1 = 0 ;
5203  double val2 ;
5204  int ecode2 = 0 ;
5205  PLFLT temp3 ;
5206  int res3 = SWIG_TMPOBJ ;
5207  PLFLT temp4 ;
5208  int res4 = SWIG_TMPOBJ ;
5209  PLINT temp5 ;
5210  int res5 = SWIG_TMPOBJ ;
5211  PyObject *swig_obj[2] ;
5212 
5213  arg3 = &temp3;
5214  arg4 = &temp4;
5215  arg5 = &temp5;
5216  if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5217  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5218  if (!SWIG_IsOK(ecode1)) {
5219  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5220  }
5221  arg1 = (PLFLT)(val1);
5222  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5223  if (!SWIG_IsOK(ecode2)) {
5224  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5225  }
5226  arg2 = (PLFLT)(val2);
5227  plcalc_world(arg1,arg2,arg3,arg4,arg5);
5228  resultobj = SWIG_Py_Void();
5229  if (SWIG_IsTmpObj(res3)) {
5230  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5231  } else {
5232  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5233  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5234  }
5235  if (SWIG_IsTmpObj(res4)) {
5236  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5237  } else {
5238  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5239  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5240  }
5241  if (SWIG_IsTmpObj(res5)) {
5242  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5243  } else {
5244  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5245  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5246  }
5247  return resultobj;
5248 fail:
5249  return NULL;
5250 }
5251 
5252 
5253 SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5254  PyObject *resultobj = 0;
5255 
5256  if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5257  plclear();
5258  resultobj = SWIG_Py_Void();
5259  return resultobj;
5260 fail:
5261  return NULL;
5262 }
5263 
5264 
5265 SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5266  PyObject *resultobj = 0;
5267  PLINT arg1 ;
5268  int val1 ;
5269  int ecode1 = 0 ;
5270  PyObject *swig_obj[1] ;
5271 
5272  if (!args) SWIG_fail;
5273  swig_obj[0] = args;
5274  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5275  if (!SWIG_IsOK(ecode1)) {
5276  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5277  }
5278  arg1 = (PLINT)(val1);
5279  plcol0(arg1);
5280  resultobj = SWIG_Py_Void();
5281  return resultobj;
5282 fail:
5283  return NULL;
5284 }
5285 
5286 
5287 SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5288  PyObject *resultobj = 0;
5289  PLFLT arg1 ;
5290  double val1 ;
5291  int ecode1 = 0 ;
5292  PyObject *swig_obj[1] ;
5293 
5294  if (!args) SWIG_fail;
5295  swig_obj[0] = args;
5296  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5297  if (!SWIG_IsOK(ecode1)) {
5298  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5299  }
5300  arg1 = (PLFLT)(val1);
5301  plcol1(arg1);
5302  resultobj = SWIG_Py_Void();
5303  return resultobj;
5304 fail:
5305  return NULL;
5306 }
5307 
5308 
5309 SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5310  PyObject *resultobj = 0;
5311  PLFLT arg1 ;
5312  PLFLT arg2 ;
5313  PLFLT arg3 ;
5314  PLINT arg4 ;
5315  PLBOOL arg5 ;
5316  PLINT arg6 ;
5317  PLINT arg7 ;
5318  PLINT arg8 ;
5319  PLINT arg9 ;
5320  PLINT arg10 ;
5321  PLFLT arg11 ;
5322  double val1 ;
5323  int ecode1 = 0 ;
5324  double val2 ;
5325  int ecode2 = 0 ;
5326  double val3 ;
5327  int ecode3 = 0 ;
5328  int val4 ;
5329  int ecode4 = 0 ;
5330  int val5 ;
5331  int ecode5 = 0 ;
5332  int val6 ;
5333  int ecode6 = 0 ;
5334  int val7 ;
5335  int ecode7 = 0 ;
5336  int val8 ;
5337  int ecode8 = 0 ;
5338  int val9 ;
5339  int ecode9 = 0 ;
5340  int val10 ;
5341  int ecode10 = 0 ;
5342  double val11 ;
5343  int ecode11 = 0 ;
5344  PyObject *swig_obj[11] ;
5345 
5346  if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5347  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5348  if (!SWIG_IsOK(ecode1)) {
5349  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5350  }
5351  arg1 = (PLFLT)(val1);
5352  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5353  if (!SWIG_IsOK(ecode2)) {
5354  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5355  }
5356  arg2 = (PLFLT)(val2);
5357  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5358  if (!SWIG_IsOK(ecode3)) {
5359  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5360  }
5361  arg3 = (PLFLT)(val3);
5362  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5363  if (!SWIG_IsOK(ecode4)) {
5364  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5365  }
5366  arg4 = (PLINT)(val4);
5367  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5368  if (!SWIG_IsOK(ecode5)) {
5369  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5370  }
5371  arg5 = (PLBOOL)(val5);
5372  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5373  if (!SWIG_IsOK(ecode6)) {
5374  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5375  }
5376  arg6 = (PLINT)(val6);
5377  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5378  if (!SWIG_IsOK(ecode7)) {
5379  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5380  }
5381  arg7 = (PLINT)(val7);
5382  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5383  if (!SWIG_IsOK(ecode8)) {
5384  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5385  }
5386  arg8 = (PLINT)(val8);
5387  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5388  if (!SWIG_IsOK(ecode9)) {
5389  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5390  }
5391  arg9 = (PLINT)(val9);
5392  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5393  if (!SWIG_IsOK(ecode10)) {
5394  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5395  }
5396  arg10 = (PLINT)(val10);
5397  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5398  if (!SWIG_IsOK(ecode11)) {
5399  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5400  }
5401  arg11 = (PLFLT)(val11);
5402  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5403  resultobj = SWIG_Py_Void();
5404  return resultobj;
5405 fail:
5406  return NULL;
5407 }
5408 
5409 
5410 SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411  PyObject *resultobj = 0;
5412  PLFLT **arg1 = (PLFLT **) 0 ;
5413  PLINT arg2 ;
5414  PLINT arg3 ;
5415  PLINT arg4 ;
5416  PLINT arg5 ;
5417  PLINT arg6 ;
5418  PLINT arg7 ;
5419  PLFLT *arg8 = (PLFLT *) 0 ;
5420  PLINT arg9 ;
5421  pltr_func arg10 = (pltr_func) 0 ;
5422  PLPointer arg11 = (PLPointer) 0 ;
5423  PyArrayObject *tmp1 = NULL ;
5424  int val4 ;
5425  int ecode4 = 0 ;
5426  int val5 ;
5427  int ecode5 = 0 ;
5428  int val6 ;
5429  int ecode6 = 0 ;
5430  int val7 ;
5431  int ecode7 = 0 ;
5432  PyArrayObject *tmp8 = NULL ;
5433  PyObject *swig_obj[8] ;
5434 
5435  {
5436  python_pltr = 0;
5437  arg10 = NULL;
5438  }
5439  {
5440  arg11 = NULL;
5441  }
5442  if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5443  {
5444  int i, size;
5445  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
5446  if ( tmp1 == NULL )
5447  return NULL;
5448  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5449  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5450  size = arg3;
5451  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5452  for ( i = 0; i < arg2; i++ )
5453  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5454  }
5455  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
5456  if (!SWIG_IsOK(ecode4)) {
5457  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5458  }
5459  arg4 = (PLINT)(val4);
5460  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
5461  if (!SWIG_IsOK(ecode5)) {
5462  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5463  }
5464  arg5 = (PLINT)(val5);
5465  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
5466  if (!SWIG_IsOK(ecode6)) {
5467  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5468  }
5469  arg6 = (PLINT)(val6);
5470  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
5471  if (!SWIG_IsOK(ecode7)) {
5472  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5473  }
5474  arg7 = (PLINT)(val7);
5475  {
5476  tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
5477  if ( tmp8 == NULL )
5478  return NULL;
5479  arg9 = PyArray_DIMS( tmp8 )[0];
5480  arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5481  }
5482  if (swig_obj[6]) {
5483  {
5484  // it must be a callable or None
5485  if ( swig_obj[6] == Py_None )
5486  {
5487  arg10 = NULL;
5488  }
5489  else
5490  {
5491  if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
5492  {
5493  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5494  return NULL;
5495  }
5496  arg10 = marshal_pltr( swig_obj[6] );
5497  }
5498  }
5499  }
5500  if (swig_obj[7]) {
5501  {
5502  if ( swig_obj[7] == Py_None )
5503  arg11 = NULL;
5504  else
5505  {
5506  arg11 = marshal_PLPointer( swig_obj[7], 0 );
5507  }
5508  }
5509  }
5510  plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5511  resultobj = SWIG_Py_Void();
5512  {
5513  Py_CLEAR( tmp1 );
5514  free( arg1 );
5515  }
5516  {
5517  Py_CLEAR( tmp8 );
5518  }
5519  {
5520  cleanup_pltr();
5521  }
5522  {
5524  }
5525  return resultobj;
5526 fail:
5527  {
5528  Py_CLEAR( tmp1 );
5529  free( arg1 );
5530  }
5531  {
5532  Py_CLEAR( tmp8 );
5533  }
5534  {
5535  cleanup_pltr();
5536  }
5537  {
5539  }
5540  return NULL;
5541 }
5542 
5543 
5544 SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5545  PyObject *resultobj = 0;
5546  PLINT arg1 ;
5547  PLINT arg2 ;
5548  PLINT arg3 ;
5549  PLINT arg4 ;
5550  PLINT arg5 ;
5551  PLFLT arg6 ;
5552  PLFLT *arg7 = (PLFLT *) 0 ;
5553  int val1 ;
5554  int ecode1 = 0 ;
5555  int val2 ;
5556  int ecode2 = 0 ;
5557  int val3 ;
5558  int ecode3 = 0 ;
5559  int val4 ;
5560  int ecode4 = 0 ;
5561  int val5 ;
5562  int ecode5 = 0 ;
5563  double val6 ;
5564  int ecode6 = 0 ;
5565  PLFLT temp7 ;
5566  int res7 = SWIG_TMPOBJ ;
5567  PyObject *swig_obj[6] ;
5568 
5569  arg7 = &temp7;
5570  if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
5571  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5572  if (!SWIG_IsOK(ecode1)) {
5573  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5574  }
5575  arg1 = (PLINT)(val1);
5576  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5577  if (!SWIG_IsOK(ecode2)) {
5578  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5579  }
5580  arg2 = (PLINT)(val2);
5581  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5582  if (!SWIG_IsOK(ecode3)) {
5583  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5584  }
5585  arg3 = (PLINT)(val3);
5586  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5587  if (!SWIG_IsOK(ecode4)) {
5588  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5589  }
5590  arg4 = (PLINT)(val4);
5591  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5592  if (!SWIG_IsOK(ecode5)) {
5593  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5594  }
5595  arg5 = (PLINT)(val5);
5596  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5597  if (!SWIG_IsOK(ecode6)) {
5598  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5599  }
5600  arg6 = (PLFLT)(val6);
5601  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5602  resultobj = SWIG_Py_Void();
5603  if (SWIG_IsTmpObj(res7)) {
5604  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5605  } else {
5606  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5607  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5608  }
5609  return resultobj;
5610 fail:
5611  return NULL;
5612 }
5613 
5614 
5615 SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616  PyObject *resultobj = 0;
5617  PLINT arg1 ;
5618  PLBOOL arg2 ;
5619  int val1 ;
5620  int ecode1 = 0 ;
5621  int val2 ;
5622  int ecode2 = 0 ;
5623  PyObject *swig_obj[2] ;
5624 
5625  if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
5626  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5627  if (!SWIG_IsOK(ecode1)) {
5628  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5629  }
5630  arg1 = (PLINT)(val1);
5631  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5632  if (!SWIG_IsOK(ecode2)) {
5633  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5634  }
5635  arg2 = (PLBOOL)(val2);
5636  plcpstrm(arg1,arg2);
5637  resultobj = SWIG_Py_Void();
5638  return resultobj;
5639 fail:
5640  return NULL;
5641 }
5642 
5643 
5644 SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5645  PyObject *resultobj = 0;
5646 
5647  if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
5648  plend();
5649  resultobj = SWIG_Py_Void();
5650  return resultobj;
5651 fail:
5652  return NULL;
5653 }
5654 
5655 
5656 SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5657  PyObject *resultobj = 0;
5658 
5659  if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
5660  plend1();
5661  resultobj = SWIG_Py_Void();
5662  return resultobj;
5663 fail:
5664  return NULL;
5665 }
5666 
5667 
5668 SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5669  PyObject *resultobj = 0;
5670  PLFLT arg1 ;
5671  PLFLT arg2 ;
5672  PLFLT arg3 ;
5673  PLFLT arg4 ;
5674  PLINT arg5 ;
5675  PLINT arg6 ;
5676  double val1 ;
5677  int ecode1 = 0 ;
5678  double val2 ;
5679  int ecode2 = 0 ;
5680  double val3 ;
5681  int ecode3 = 0 ;
5682  double val4 ;
5683  int ecode4 = 0 ;
5684  int val5 ;
5685  int ecode5 = 0 ;
5686  int val6 ;
5687  int ecode6 = 0 ;
5688  PyObject *swig_obj[6] ;
5689 
5690  if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
5691  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5692  if (!SWIG_IsOK(ecode1)) {
5693  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5694  }
5695  arg1 = (PLFLT)(val1);
5696  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5697  if (!SWIG_IsOK(ecode2)) {
5698  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5699  }
5700  arg2 = (PLFLT)(val2);
5701  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5702  if (!SWIG_IsOK(ecode3)) {
5703  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5704  }
5705  arg3 = (PLFLT)(val3);
5706  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5707  if (!SWIG_IsOK(ecode4)) {
5708  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5709  }
5710  arg4 = (PLFLT)(val4);
5711  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5712  if (!SWIG_IsOK(ecode5)) {
5713  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5714  }
5715  arg5 = (PLINT)(val5);
5716  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5717  if (!SWIG_IsOK(ecode6)) {
5718  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5719  }
5720  arg6 = (PLINT)(val6);
5721  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5722  resultobj = SWIG_Py_Void();
5723  return resultobj;
5724 fail:
5725  return NULL;
5726 }
5727 
5728 
5729 SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730  PyObject *resultobj = 0;
5731  PLFLT arg1 ;
5732  PLFLT arg2 ;
5733  PLFLT arg3 ;
5734  PLFLT arg4 ;
5735  PLINT arg5 ;
5736  PLINT arg6 ;
5737  double val1 ;
5738  int ecode1 = 0 ;
5739  double val2 ;
5740  int ecode2 = 0 ;
5741  double val3 ;
5742  int ecode3 = 0 ;
5743  double val4 ;
5744  int ecode4 = 0 ;
5745  int val5 ;
5746  int ecode5 = 0 ;
5747  int val6 ;
5748  int ecode6 = 0 ;
5749  PyObject *swig_obj[6] ;
5750 
5751  if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
5752  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5753  if (!SWIG_IsOK(ecode1)) {
5754  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
5755  }
5756  arg1 = (PLFLT)(val1);
5757  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5758  if (!SWIG_IsOK(ecode2)) {
5759  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
5760  }
5761  arg2 = (PLFLT)(val2);
5762  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5763  if (!SWIG_IsOK(ecode3)) {
5764  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
5765  }
5766  arg3 = (PLFLT)(val3);
5767  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5768  if (!SWIG_IsOK(ecode4)) {
5769  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
5770  }
5771  arg4 = (PLFLT)(val4);
5772  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5773  if (!SWIG_IsOK(ecode5)) {
5774  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
5775  }
5776  arg5 = (PLINT)(val5);
5777  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5778  if (!SWIG_IsOK(ecode6)) {
5779  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
5780  }
5781  arg6 = (PLINT)(val6);
5782  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
5783  resultobj = SWIG_Py_Void();
5784  return resultobj;
5785 fail:
5786  return NULL;
5787 }
5788 
5789 
5790 SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5791  PyObject *resultobj = 0;
5792 
5793  if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
5794  pleop();
5795  resultobj = SWIG_Py_Void();
5796  return resultobj;
5797 fail:
5798  return NULL;
5799 }
5800 
5801 
5802 SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5803  PyObject *resultobj = 0;
5804  PLINT arg1 ;
5805  PLFLT *arg2 = (PLFLT *) 0 ;
5806  PLFLT *arg3 = (PLFLT *) 0 ;
5807  PLFLT *arg4 = (PLFLT *) 0 ;
5808  PyArrayObject *tmp1 = NULL ;
5809  PyArrayObject *tmp3 = NULL ;
5810  PyArrayObject *tmp4 = NULL ;
5811  PyObject *swig_obj[3] ;
5812 
5813  if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
5814  {
5815  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5816  if ( tmp1 == NULL )
5817  return NULL;
5818  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5819  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5820  }
5821  {
5822  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5823  if ( tmp3 == NULL )
5824  return NULL;
5825  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5826  {
5827  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5828  return NULL;
5829  }
5830  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5831  }
5832  {
5833  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5834  if ( tmp4 == NULL )
5835  return NULL;
5836  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5837  {
5838  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5839  return NULL;
5840  }
5841  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5842  }
5843  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5844  resultobj = SWIG_Py_Void();
5845  {
5846  Py_CLEAR( tmp1 );
5847  }
5848  {
5849  Py_CLEAR( tmp3 );
5850  }
5851  {
5852  Py_CLEAR( tmp4 );
5853  }
5854  return resultobj;
5855 fail:
5856  {
5857  Py_CLEAR( tmp1 );
5858  }
5859  {
5860  Py_CLEAR( tmp3 );
5861  }
5862  {
5863  Py_CLEAR( tmp4 );
5864  }
5865  return NULL;
5866 }
5867 
5868 
5869 SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5870  PyObject *resultobj = 0;
5871  PLINT arg1 ;
5872  PLFLT *arg2 = (PLFLT *) 0 ;
5873  PLFLT *arg3 = (PLFLT *) 0 ;
5874  PLFLT *arg4 = (PLFLT *) 0 ;
5875  PyArrayObject *tmp1 = NULL ;
5876  PyArrayObject *tmp3 = NULL ;
5877  PyArrayObject *tmp4 = NULL ;
5878  PyObject *swig_obj[3] ;
5879 
5880  if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
5881  {
5882  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5883  if ( tmp1 == NULL )
5884  return NULL;
5885  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5886  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5887  }
5888  {
5889  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5890  if ( tmp3 == NULL )
5891  return NULL;
5892  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5893  {
5894  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5895  return NULL;
5896  }
5897  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5898  }
5899  {
5900  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5901  if ( tmp4 == NULL )
5902  return NULL;
5903  if ( PyArray_DIMS( tmp4 )[0] != Alen )
5904  {
5905  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5906  return NULL;
5907  }
5908  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5909  }
5910  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5911  resultobj = SWIG_Py_Void();
5912  {
5913  Py_CLEAR( tmp1 );
5914  }
5915  {
5916  Py_CLEAR( tmp3 );
5917  }
5918  {
5919  Py_CLEAR( tmp4 );
5920  }
5921  return resultobj;
5922 fail:
5923  {
5924  Py_CLEAR( tmp1 );
5925  }
5926  {
5927  Py_CLEAR( tmp3 );
5928  }
5929  {
5930  Py_CLEAR( tmp4 );
5931  }
5932  return NULL;
5933 }
5934 
5935 
5936 SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5937  PyObject *resultobj = 0;
5938 
5939  if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
5940  plfamadv();
5941  resultobj = SWIG_Py_Void();
5942  return resultobj;
5943 fail:
5944  return NULL;
5945 }
5946 
5947 
5948 SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5949  PyObject *resultobj = 0;
5950  PLINT arg1 ;
5951  PLFLT *arg2 = (PLFLT *) 0 ;
5952  PLFLT *arg3 = (PLFLT *) 0 ;
5953  PyArrayObject *tmp1 = NULL ;
5954  PyArrayObject *tmp3 = NULL ;
5955  PyObject *swig_obj[2] ;
5956 
5957  if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
5958  {
5959  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5960  if ( tmp1 == NULL )
5961  return NULL;
5962  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5963  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5964  }
5965  {
5966  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5967  if ( tmp3 == NULL )
5968  return NULL;
5969  if ( PyArray_DIMS( tmp3 )[0] != Alen )
5970  {
5971  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5972  return NULL;
5973  }
5974  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5975  }
5976  plfill(arg1,(double const *)arg2,(double const *)arg3);
5977  resultobj = SWIG_Py_Void();
5978  {
5979  Py_CLEAR( tmp1 );
5980  }
5981  {
5982  Py_CLEAR( tmp3 );
5983  }
5984  return resultobj;
5985 fail:
5986  {
5987  Py_CLEAR( tmp1 );
5988  }
5989  {
5990  Py_CLEAR( tmp3 );
5991  }
5992  return NULL;
5993 }
5994 
5995 
5996 SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5997  PyObject *resultobj = 0;
5998  PLINT arg1 ;
5999  PLFLT *arg2 = (PLFLT *) 0 ;
6000  PLFLT *arg3 = (PLFLT *) 0 ;
6001  PLFLT *arg4 = (PLFLT *) 0 ;
6002  PyArrayObject *tmp1 = NULL ;
6003  PyArrayObject *tmp3 = NULL ;
6004  PyArrayObject *tmp4 = NULL ;
6005  PyObject *swig_obj[3] ;
6006 
6007  if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6008  {
6009  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6010  if ( tmp1 == NULL )
6011  return NULL;
6012  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6013  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6014  }
6015  {
6016  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6017  if ( tmp3 == NULL )
6018  return NULL;
6019  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6020  {
6021  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6022  return NULL;
6023  }
6024  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6025  }
6026  {
6027  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6028  if ( tmp4 == NULL )
6029  return NULL;
6030  if ( PyArray_DIMS( tmp4 )[0] != Alen )
6031  {
6032  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6033  return NULL;
6034  }
6035  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6036  }
6037  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6038  resultobj = SWIG_Py_Void();
6039  {
6040  Py_CLEAR( tmp1 );
6041  }
6042  {
6043  Py_CLEAR( tmp3 );
6044  }
6045  {
6046  Py_CLEAR( tmp4 );
6047  }
6048  return resultobj;
6049 fail:
6050  {
6051  Py_CLEAR( tmp1 );
6052  }
6053  {
6054  Py_CLEAR( tmp3 );
6055  }
6056  {
6057  Py_CLEAR( tmp4 );
6058  }
6059  return NULL;
6060 }
6061 
6062 
6063 SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6064  PyObject *resultobj = 0;
6065  PLINT arg1 ;
6066  PLFLT *arg2 = (PLFLT *) 0 ;
6067  PLFLT *arg3 = (PLFLT *) 0 ;
6068  PLFLT arg4 ;
6069  PyArrayObject *tmp1 = NULL ;
6070  PyArrayObject *tmp3 = NULL ;
6071  double val4 ;
6072  int ecode4 = 0 ;
6073  PyObject *swig_obj[3] ;
6074 
6075  if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6076  {
6077  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6078  if ( tmp1 == NULL )
6079  return NULL;
6080  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6081  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6082  }
6083  {
6084  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6085  if ( tmp3 == NULL )
6086  return NULL;
6087  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6088  {
6089  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6090  return NULL;
6091  }
6092  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6093  }
6094  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6095  if (!SWIG_IsOK(ecode4)) {
6096  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6097  }
6098  arg4 = (PLFLT)(val4);
6099  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6100  resultobj = SWIG_Py_Void();
6101  {
6102  Py_CLEAR( tmp1 );
6103  }
6104  {
6105  Py_CLEAR( tmp3 );
6106  }
6107  return resultobj;
6108 fail:
6109  {
6110  Py_CLEAR( tmp1 );
6111  }
6112  {
6113  Py_CLEAR( tmp3 );
6114  }
6115  return NULL;
6116 }
6117 
6118 
6119 SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6120  PyObject *resultobj = 0;
6121 
6122  if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6123  plflush();
6124  resultobj = SWIG_Py_Void();
6125  return resultobj;
6126 fail:
6127  return NULL;
6128 }
6129 
6130 
6131 SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6132  PyObject *resultobj = 0;
6133  PLINT arg1 ;
6134  int val1 ;
6135  int ecode1 = 0 ;
6136  PyObject *swig_obj[1] ;
6137 
6138  if (!args) SWIG_fail;
6139  swig_obj[0] = args;
6140  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6141  if (!SWIG_IsOK(ecode1)) {
6142  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6143  }
6144  arg1 = (PLINT)(val1);
6145  plfont(arg1);
6146  resultobj = SWIG_Py_Void();
6147  return resultobj;
6148 fail:
6149  return NULL;
6150 }
6151 
6152 
6153 SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154  PyObject *resultobj = 0;
6155  PLINT arg1 ;
6156  int val1 ;
6157  int ecode1 = 0 ;
6158  PyObject *swig_obj[1] ;
6159 
6160  if (!args) SWIG_fail;
6161  swig_obj[0] = args;
6162  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6163  if (!SWIG_IsOK(ecode1)) {
6164  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6165  }
6166  arg1 = (PLINT)(val1);
6167  plfontld(arg1);
6168  resultobj = SWIG_Py_Void();
6169  return resultobj;
6170 fail:
6171  return NULL;
6172 }
6173 
6174 
6175 SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6176  PyObject *resultobj = 0;
6177  PLFLT *arg1 = (PLFLT *) 0 ;
6178  PLFLT *arg2 = (PLFLT *) 0 ;
6179  PLFLT temp1 ;
6180  int res1 = SWIG_TMPOBJ ;
6181  PLFLT temp2 ;
6182  int res2 = SWIG_TMPOBJ ;
6183 
6184  arg1 = &temp1;
6185  arg2 = &temp2;
6186  if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6187  plgchr(arg1,arg2);
6188  resultobj = SWIG_Py_Void();
6189  if (SWIG_IsTmpObj(res1)) {
6190  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6191  } else {
6192  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6193  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6194  }
6195  if (SWIG_IsTmpObj(res2)) {
6196  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6197  } else {
6198  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6199  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6200  }
6201  return resultobj;
6202 fail:
6203  return NULL;
6204 }
6205 
6206 
6207 SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6208  PyObject *resultobj = 0;
6209  PLINT arg1 ;
6210  PLINT *arg2 = (PLINT *) 0 ;
6211  PLINT *arg3 = (PLINT *) 0 ;
6212  PLINT *arg4 = (PLINT *) 0 ;
6213  int val1 ;
6214  int ecode1 = 0 ;
6215  PLINT temp2 ;
6216  int res2 = SWIG_TMPOBJ ;
6217  PLINT temp3 ;
6218  int res3 = SWIG_TMPOBJ ;
6219  PLINT temp4 ;
6220  int res4 = SWIG_TMPOBJ ;
6221  PyObject *swig_obj[1] ;
6222 
6223  arg2 = &temp2;
6224  arg3 = &temp3;
6225  arg4 = &temp4;
6226  if (!args) SWIG_fail;
6227  swig_obj[0] = args;
6228  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6229  if (!SWIG_IsOK(ecode1)) {
6230  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6231  }
6232  arg1 = (PLINT)(val1);
6233  plgcol0(arg1,arg2,arg3,arg4);
6234  resultobj = SWIG_Py_Void();
6235  if (SWIG_IsTmpObj(res2)) {
6236  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6237  } else {
6238  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6239  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6240  }
6241  if (SWIG_IsTmpObj(res3)) {
6242  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6243  } else {
6244  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6245  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6246  }
6247  if (SWIG_IsTmpObj(res4)) {
6248  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6249  } else {
6250  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6251  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6252  }
6253  return resultobj;
6254 fail:
6255  return NULL;
6256 }
6257 
6258 
6259 SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6260  PyObject *resultobj = 0;
6261  PLINT arg1 ;
6262  PLINT *arg2 = (PLINT *) 0 ;
6263  PLINT *arg3 = (PLINT *) 0 ;
6264  PLINT *arg4 = (PLINT *) 0 ;
6265  PLFLT *arg5 = (PLFLT *) 0 ;
6266  int val1 ;
6267  int ecode1 = 0 ;
6268  PLINT temp2 ;
6269  int res2 = SWIG_TMPOBJ ;
6270  PLINT temp3 ;
6271  int res3 = SWIG_TMPOBJ ;
6272  PLINT temp4 ;
6273  int res4 = SWIG_TMPOBJ ;
6274  PLFLT temp5 ;
6275  int res5 = SWIG_TMPOBJ ;
6276  PyObject *swig_obj[1] ;
6277 
6278  arg2 = &temp2;
6279  arg3 = &temp3;
6280  arg4 = &temp4;
6281  arg5 = &temp5;
6282  if (!args) SWIG_fail;
6283  swig_obj[0] = args;
6284  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6285  if (!SWIG_IsOK(ecode1)) {
6286  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6287  }
6288  arg1 = (PLINT)(val1);
6289  plgcol0a(arg1,arg2,arg3,arg4,arg5);
6290  resultobj = SWIG_Py_Void();
6291  if (SWIG_IsTmpObj(res2)) {
6292  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6293  } else {
6294  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6295  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6296  }
6297  if (SWIG_IsTmpObj(res3)) {
6298  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6299  } else {
6300  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6301  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6302  }
6303  if (SWIG_IsTmpObj(res4)) {
6304  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6305  } else {
6306  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6307  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6308  }
6309  if (SWIG_IsTmpObj(res5)) {
6310  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6311  } else {
6312  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6313  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6314  }
6315  return resultobj;
6316 fail:
6317  return NULL;
6318 }
6319 
6320 
6321 SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6322  PyObject *resultobj = 0;
6323  PLINT *arg1 = (PLINT *) 0 ;
6324  PLINT *arg2 = (PLINT *) 0 ;
6325  PLINT *arg3 = (PLINT *) 0 ;
6326  PLINT temp1 ;
6327  int res1 = SWIG_TMPOBJ ;
6328  PLINT temp2 ;
6329  int res2 = SWIG_TMPOBJ ;
6330  PLINT temp3 ;
6331  int res3 = SWIG_TMPOBJ ;
6332 
6333  arg1 = &temp1;
6334  arg2 = &temp2;
6335  arg3 = &temp3;
6336  if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6337  plgcolbg(arg1,arg2,arg3);
6338  resultobj = SWIG_Py_Void();
6339  if (SWIG_IsTmpObj(res1)) {
6340  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6341  } else {
6342  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6343  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6344  }
6345  if (SWIG_IsTmpObj(res2)) {
6346  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6347  } else {
6348  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6349  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6350  }
6351  if (SWIG_IsTmpObj(res3)) {
6352  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6353  } else {
6354  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6355  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6356  }
6357  return resultobj;
6358 fail:
6359  return NULL;
6360 }
6361 
6362 
6363 SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6364  PyObject *resultobj = 0;
6365  PLINT *arg1 = (PLINT *) 0 ;
6366  PLINT *arg2 = (PLINT *) 0 ;
6367  PLINT *arg3 = (PLINT *) 0 ;
6368  PLFLT *arg4 = (PLFLT *) 0 ;
6369  PLINT temp1 ;
6370  int res1 = SWIG_TMPOBJ ;
6371  PLINT temp2 ;
6372  int res2 = SWIG_TMPOBJ ;
6373  PLINT temp3 ;
6374  int res3 = SWIG_TMPOBJ ;
6375  PLFLT temp4 ;
6376  int res4 = SWIG_TMPOBJ ;
6377 
6378  arg1 = &temp1;
6379  arg2 = &temp2;
6380  arg3 = &temp3;
6381  arg4 = &temp4;
6382  if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6383  plgcolbga(arg1,arg2,arg3,arg4);
6384  resultobj = SWIG_Py_Void();
6385  if (SWIG_IsTmpObj(res1)) {
6386  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6387  } else {
6388  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6389  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6390  }
6391  if (SWIG_IsTmpObj(res2)) {
6392  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6393  } else {
6394  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6395  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6396  }
6397  if (SWIG_IsTmpObj(res3)) {
6398  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6399  } else {
6400  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6401  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6402  }
6403  if (SWIG_IsTmpObj(res4)) {
6404  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6405  } else {
6406  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6407  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6408  }
6409  return resultobj;
6410 fail:
6411  return NULL;
6412 }
6413 
6414 
6415 SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6416  PyObject *resultobj = 0;
6417  PLINT *arg1 = (PLINT *) 0 ;
6418  PLINT temp1 ;
6419  int res1 = SWIG_TMPOBJ ;
6420 
6421  arg1 = &temp1;
6422  if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
6423  plgcompression(arg1);
6424  resultobj = SWIG_Py_Void();
6425  if (SWIG_IsTmpObj(res1)) {
6426  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6427  } else {
6428  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6429  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6430  }
6431  return resultobj;
6432 fail:
6433  return NULL;
6434 }
6435 
6436 
6437 SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438  PyObject *resultobj = 0;
6439  char *arg1 = (char *) 0 ;
6440  char buff1[1000] ;
6441 
6442  {
6443  arg1 = buff1;
6444  }
6445  if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
6446  plgdev(arg1);
6447  resultobj = SWIG_Py_Void();
6448  {
6449  PyObject *o = PyString_FromString( arg1 );
6450  resultobj = t_output_helper( resultobj, o );
6451  }
6452  return resultobj;
6453 fail:
6454  return NULL;
6455 }
6456 
6457 
6458 SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6459  PyObject *resultobj = 0;
6460  PLFLT *arg1 = (PLFLT *) 0 ;
6461  PLFLT *arg2 = (PLFLT *) 0 ;
6462  PLFLT *arg3 = (PLFLT *) 0 ;
6463  PLFLT *arg4 = (PLFLT *) 0 ;
6464  PLFLT temp1 ;
6465  int res1 = SWIG_TMPOBJ ;
6466  PLFLT temp2 ;
6467  int res2 = SWIG_TMPOBJ ;
6468  PLFLT temp3 ;
6469  int res3 = SWIG_TMPOBJ ;
6470  PLFLT temp4 ;
6471  int res4 = SWIG_TMPOBJ ;
6472 
6473  arg1 = &temp1;
6474  arg2 = &temp2;
6475  arg3 = &temp3;
6476  arg4 = &temp4;
6477  if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
6478  plgdidev(arg1,arg2,arg3,arg4);
6479  resultobj = SWIG_Py_Void();
6480  if (SWIG_IsTmpObj(res1)) {
6481  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6482  } else {
6483  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6484  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6485  }
6486  if (SWIG_IsTmpObj(res2)) {
6487  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6488  } else {
6489  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6490  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6491  }
6492  if (SWIG_IsTmpObj(res3)) {
6493  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6494  } else {
6495  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6496  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6497  }
6498  if (SWIG_IsTmpObj(res4)) {
6499  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6500  } else {
6501  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6502  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6503  }
6504  return resultobj;
6505 fail:
6506  return NULL;
6507 }
6508 
6509 
6510 SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6511  PyObject *resultobj = 0;
6512  PLFLT *arg1 = (PLFLT *) 0 ;
6513  PLFLT temp1 ;
6514  int res1 = SWIG_TMPOBJ ;
6515 
6516  arg1 = &temp1;
6517  if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
6518  plgdiori(arg1);
6519  resultobj = SWIG_Py_Void();
6520  if (SWIG_IsTmpObj(res1)) {
6521  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6522  } else {
6523  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6524  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6525  }
6526  return resultobj;
6527 fail:
6528  return NULL;
6529 }
6530 
6531 
6532 SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6533  PyObject *resultobj = 0;
6534  PLFLT *arg1 = (PLFLT *) 0 ;
6535  PLFLT *arg2 = (PLFLT *) 0 ;
6536  PLFLT *arg3 = (PLFLT *) 0 ;
6537  PLFLT *arg4 = (PLFLT *) 0 ;
6538  PLFLT temp1 ;
6539  int res1 = SWIG_TMPOBJ ;
6540  PLFLT temp2 ;
6541  int res2 = SWIG_TMPOBJ ;
6542  PLFLT temp3 ;
6543  int res3 = SWIG_TMPOBJ ;
6544  PLFLT temp4 ;
6545  int res4 = SWIG_TMPOBJ ;
6546 
6547  arg1 = &temp1;
6548  arg2 = &temp2;
6549  arg3 = &temp3;
6550  arg4 = &temp4;
6551  if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
6552  plgdiplt(arg1,arg2,arg3,arg4);
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  if (SWIG_IsTmpObj(res2)) {
6561  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6562  } else {
6563  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6564  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6565  }
6566  if (SWIG_IsTmpObj(res3)) {
6567  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6568  } else {
6569  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6570  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6571  }
6572  if (SWIG_IsTmpObj(res4)) {
6573  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6574  } else {
6575  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6576  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6577  }
6578  return resultobj;
6579 fail:
6580  return NULL;
6581 }
6582 
6583 
6584 SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6585  PyObject *resultobj = 0;
6586  PLINT *arg1 = (PLINT *) 0 ;
6587  PLINT *arg2 = (PLINT *) 0 ;
6588  PLINT *arg3 = (PLINT *) 0 ;
6589  PLINT temp1 ;
6590  int res1 = SWIG_TMPOBJ ;
6591  PLINT temp2 ;
6592  int res2 = SWIG_TMPOBJ ;
6593  PLINT temp3 ;
6594  int res3 = SWIG_TMPOBJ ;
6595 
6596  arg1 = &temp1;
6597  arg2 = &temp2;
6598  arg3 = &temp3;
6599  if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
6600  plgfam(arg1,arg2,arg3);
6601  resultobj = SWIG_Py_Void();
6602  if (SWIG_IsTmpObj(res1)) {
6603  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6604  } else {
6605  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6606  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6607  }
6608  if (SWIG_IsTmpObj(res2)) {
6609  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6610  } else {
6611  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6612  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6613  }
6614  if (SWIG_IsTmpObj(res3)) {
6615  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6616  } else {
6617  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6618  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6619  }
6620  return resultobj;
6621 fail:
6622  return NULL;
6623 }
6624 
6625 
6626 SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6627  PyObject *resultobj = 0;
6628  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6629  PLUNICODE temp1 ;
6630  int res1 = SWIG_TMPOBJ ;
6631 
6632  arg1 = &temp1;
6633  if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
6634  plgfci(arg1);
6635  resultobj = SWIG_Py_Void();
6636  if (SWIG_IsTmpObj(res1)) {
6637  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_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_unsigned_int, new_flags));
6641  }
6642  return resultobj;
6643 fail:
6644  return NULL;
6645 }
6646 
6647 
6648 SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6649  PyObject *resultobj = 0;
6650  char *arg1 = (char *) 0 ;
6651  char buff1[1000] ;
6652 
6653  {
6654  arg1 = buff1;
6655  }
6656  if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
6657  plgfnam(arg1);
6658  resultobj = SWIG_Py_Void();
6659  {
6660  PyObject *o = PyString_FromString( arg1 );
6661  resultobj = t_output_helper( resultobj, o );
6662  }
6663  return resultobj;
6664 fail:
6665  return NULL;
6666 }
6667 
6668 
6669 SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670  PyObject *resultobj = 0;
6671  PLINT *arg1 = (PLINT *) 0 ;
6672  PLINT *arg2 = (PLINT *) 0 ;
6673  PLINT *arg3 = (PLINT *) 0 ;
6674  PLINT temp1 ;
6675  int res1 = SWIG_TMPOBJ ;
6676  PLINT temp2 ;
6677  int res2 = SWIG_TMPOBJ ;
6678  PLINT temp3 ;
6679  int res3 = SWIG_TMPOBJ ;
6680 
6681  arg1 = &temp1;
6682  arg2 = &temp2;
6683  arg3 = &temp3;
6684  if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
6685  plgfont(arg1,arg2,arg3);
6686  resultobj = SWIG_Py_Void();
6687  if (SWIG_IsTmpObj(res1)) {
6688  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6689  } else {
6690  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6691  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6692  }
6693  if (SWIG_IsTmpObj(res2)) {
6694  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6695  } else {
6696  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6697  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6698  }
6699  if (SWIG_IsTmpObj(res3)) {
6700  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6701  } else {
6702  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6703  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6704  }
6705  return resultobj;
6706 fail:
6707  return NULL;
6708 }
6709 
6710 
6711 SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6712  PyObject *resultobj = 0;
6713  PLINT *arg1 = (PLINT *) 0 ;
6714  PLINT temp1 ;
6715  int res1 = SWIG_TMPOBJ ;
6716 
6717  arg1 = &temp1;
6718  if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
6719  plglevel(arg1);
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  return resultobj;
6728 fail:
6729  return NULL;
6730 }
6731 
6732 
6733 SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734  PyObject *resultobj = 0;
6735  PLFLT *arg1 = (PLFLT *) 0 ;
6736  PLFLT *arg2 = (PLFLT *) 0 ;
6737  PLINT *arg3 = (PLINT *) 0 ;
6738  PLINT *arg4 = (PLINT *) 0 ;
6739  PLINT *arg5 = (PLINT *) 0 ;
6740  PLINT *arg6 = (PLINT *) 0 ;
6741  PLFLT temp1 ;
6742  int res1 = SWIG_TMPOBJ ;
6743  PLFLT temp2 ;
6744  int res2 = SWIG_TMPOBJ ;
6745  PLINT temp3 ;
6746  int res3 = SWIG_TMPOBJ ;
6747  PLINT temp4 ;
6748  int res4 = SWIG_TMPOBJ ;
6749  PLINT temp5 ;
6750  int res5 = SWIG_TMPOBJ ;
6751  PLINT temp6 ;
6752  int res6 = SWIG_TMPOBJ ;
6753 
6754  arg1 = &temp1;
6755  arg2 = &temp2;
6756  arg3 = &temp3;
6757  arg4 = &temp4;
6758  arg5 = &temp5;
6759  arg6 = &temp6;
6760  if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
6761  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
6762  resultobj = SWIG_Py_Void();
6763  if (SWIG_IsTmpObj(res1)) {
6764  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6765  } else {
6766  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6767  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6768  }
6769  if (SWIG_IsTmpObj(res2)) {
6770  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6771  } else {
6772  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6773  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6774  }
6775  if (SWIG_IsTmpObj(res3)) {
6776  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6777  } else {
6778  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6779  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6780  }
6781  if (SWIG_IsTmpObj(res4)) {
6782  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6783  } else {
6784  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6785  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6786  }
6787  if (SWIG_IsTmpObj(res5)) {
6788  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
6789  } else {
6790  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6791  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
6792  }
6793  if (SWIG_IsTmpObj(res6)) {
6794  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
6795  } else {
6796  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6797  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
6798  }
6799  return resultobj;
6800 fail:
6801  return NULL;
6802 }
6803 
6804 
6805 SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6806  PyObject *resultobj = 0;
6807 
6808  if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
6809  plgra();
6810  resultobj = SWIG_Py_Void();
6811  return resultobj;
6812 fail:
6813  return NULL;
6814 }
6815 
6816 
6817 SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818  PyObject *resultobj = 0;
6819  PLFLT *arg1 = (PLFLT *) 0 ;
6820  PLFLT *arg2 = (PLFLT *) 0 ;
6821  PLFLT *arg3 = (PLFLT *) 0 ;
6822  PLINT arg4 ;
6823  PLFLT *arg5 = (PLFLT *) 0 ;
6824  PLINT arg6 ;
6825  PLFLT *arg7 = (PLFLT *) 0 ;
6826  PLINT arg8 ;
6827  PLFLT **arg9 = (PLFLT **) 0 ;
6828  PLINT arg10 ;
6829  PLFLT arg11 ;
6830  PyArrayObject *tmp1 = NULL ;
6831  PyArrayObject *tmp2 = NULL ;
6832  PyArrayObject *tmp3 = NULL ;
6833  PyArrayObject *tmp5 = NULL ;
6834  PyArrayObject *tmp7 = NULL ;
6835  PyObject *array7 = NULL ;
6836  int val10 ;
6837  int ecode10 = 0 ;
6838  double val11 ;
6839  int ecode11 = 0 ;
6840  PyObject *swig_obj[7] ;
6841 
6842  if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
6843  {
6844  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6845  if ( tmp1 == NULL )
6846  return NULL;
6847  Alen = PyArray_DIMS( tmp1 )[0];
6848  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
6849  }
6850  {
6851  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6852  if ( tmp2 == NULL )
6853  return NULL;
6854  if ( PyArray_DIMS( tmp2 )[0] != Alen )
6855  {
6856  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6857  return NULL;
6858  }
6859  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
6860  }
6861  {
6862  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6863  if ( tmp3 == NULL )
6864  return NULL;
6865  if ( PyArray_DIMS( tmp3 )[0] != Alen )
6866  {
6867  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6868  return NULL;
6869  }
6870  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6871  arg4 = PyArray_DIMS( tmp3 )[0];
6872  }
6873  {
6874  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
6875  if ( tmp5 == NULL )
6876  return NULL;
6877  Xlen = PyArray_DIMS( tmp5 )[0];
6878  arg6 = Xlen;
6879  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
6880  }
6881  {
6882  int i, size;
6883  npy_intp dims[2];
6884  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
6885  if ( tmp7 == NULL )
6886  return NULL;
6887  Ylen = PyArray_DIMS( tmp7 )[0];
6888  arg8 = Ylen;
6889  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
6890  // Make created 2D array7 have dimensions from prior ArrayX in the argument
6891  // list and this ArrayY.
6892  dims[0] = Xlen;
6893  dims[1] = Ylen;
6894  array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
6895  if ( !array7 )
6896  return NULL;
6897  size = Ylen;
6898  arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
6899  for ( i = 0; i < Xlen; i++ )
6900  arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
6901  }
6902  ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
6903  if (!SWIG_IsOK(ecode10)) {
6904  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
6905  }
6906  arg10 = (PLINT)(val10);
6907  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
6908  if (!SWIG_IsOK(ecode11)) {
6909  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
6910  }
6911  arg11 = (PLFLT)(val11);
6912  plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
6913  resultobj = SWIG_Py_Void();
6914  {
6915  resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
6916  }
6917  {
6918  Py_CLEAR( tmp1 );
6919  }
6920  {
6921  Py_CLEAR( tmp2 );
6922  }
6923  {
6924  Py_CLEAR( tmp3 );
6925  }
6926  {
6927  Py_CLEAR( tmp5 );
6928  }
6929  {
6930  Py_CLEAR( tmp7 );
6931  free( arg9 );
6932  }
6933  return resultobj;
6934 fail:
6935  {
6936  Py_CLEAR( tmp1 );
6937  }
6938  {
6939  Py_CLEAR( tmp2 );
6940  }
6941  {
6942  Py_CLEAR( tmp3 );
6943  }
6944  {
6945  Py_CLEAR( tmp5 );
6946  }
6947  {
6948  Py_CLEAR( tmp7 );
6949  free( arg9 );
6950  }
6951  return NULL;
6952 }
6953 
6954 
6955 SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6956  PyObject *resultobj = 0;
6957  PLFLT *arg1 = (PLFLT *) 0 ;
6958  PLFLT *arg2 = (PLFLT *) 0 ;
6959  PLFLT *arg3 = (PLFLT *) 0 ;
6960  PLFLT *arg4 = (PLFLT *) 0 ;
6961  PLFLT temp1 ;
6962  int res1 = SWIG_TMPOBJ ;
6963  PLFLT temp2 ;
6964  int res2 = SWIG_TMPOBJ ;
6965  PLFLT temp3 ;
6966  int res3 = SWIG_TMPOBJ ;
6967  PLFLT temp4 ;
6968  int res4 = SWIG_TMPOBJ ;
6969 
6970  arg1 = &temp1;
6971  arg2 = &temp2;
6972  arg3 = &temp3;
6973  arg4 = &temp4;
6974  if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
6975  plgspa(arg1,arg2,arg3,arg4);
6976  resultobj = SWIG_Py_Void();
6977  if (SWIG_IsTmpObj(res1)) {
6978  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6979  } else {
6980  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6982  }
6983  if (SWIG_IsTmpObj(res2)) {
6984  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6985  } else {
6986  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6988  }
6989  if (SWIG_IsTmpObj(res3)) {
6990  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6991  } else {
6992  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6993  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6994  }
6995  if (SWIG_IsTmpObj(res4)) {
6996  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6997  } else {
6998  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6999  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7000  }
7001  return resultobj;
7002 fail:
7003  return NULL;
7004 }
7005 
7006 
7007 SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7008  PyObject *resultobj = 0;
7009  PLINT *arg1 = (PLINT *) 0 ;
7010  PLINT temp1 ;
7011  int res1 = SWIG_TMPOBJ ;
7012 
7013  arg1 = &temp1;
7014  if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7015  plgstrm(arg1);
7016  resultobj = SWIG_Py_Void();
7017  if (SWIG_IsTmpObj(res1)) {
7018  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7019  } else {
7020  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7021  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7022  }
7023  return resultobj;
7024 fail:
7025  return NULL;
7026 }
7027 
7028 
7029 SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7030  PyObject *resultobj = 0;
7031  char *arg1 = (char *) 0 ;
7032  char buff1[1000] ;
7033 
7034  {
7035  arg1 = buff1;
7036  }
7037  if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7038  plgver(arg1);
7039  resultobj = SWIG_Py_Void();
7040  {
7041  PyObject *o = PyString_FromString( arg1 );
7042  resultobj = t_output_helper( resultobj, o );
7043  }
7044  return resultobj;
7045 fail:
7046  return NULL;
7047 }
7048 
7049 
7050 SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051  PyObject *resultobj = 0;
7052  PLFLT *arg1 = (PLFLT *) 0 ;
7053  PLFLT *arg2 = (PLFLT *) 0 ;
7054  PLFLT *arg3 = (PLFLT *) 0 ;
7055  PLFLT *arg4 = (PLFLT *) 0 ;
7056  PLFLT temp1 ;
7057  int res1 = SWIG_TMPOBJ ;
7058  PLFLT temp2 ;
7059  int res2 = SWIG_TMPOBJ ;
7060  PLFLT temp3 ;
7061  int res3 = SWIG_TMPOBJ ;
7062  PLFLT temp4 ;
7063  int res4 = SWIG_TMPOBJ ;
7064 
7065  arg1 = &temp1;
7066  arg2 = &temp2;
7067  arg3 = &temp3;
7068  arg4 = &temp4;
7069  if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7070  plgvpd(arg1,arg2,arg3,arg4);
7071  resultobj = SWIG_Py_Void();
7072  if (SWIG_IsTmpObj(res1)) {
7073  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7074  } else {
7075  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7076  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7077  }
7078  if (SWIG_IsTmpObj(res2)) {
7079  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7080  } else {
7081  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7082  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7083  }
7084  if (SWIG_IsTmpObj(res3)) {
7085  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7086  } else {
7087  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7088  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7089  }
7090  if (SWIG_IsTmpObj(res4)) {
7091  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7092  } else {
7093  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7094  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7095  }
7096  return resultobj;
7097 fail:
7098  return NULL;
7099 }
7100 
7101 
7102 SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7103  PyObject *resultobj = 0;
7104  PLFLT *arg1 = (PLFLT *) 0 ;
7105  PLFLT *arg2 = (PLFLT *) 0 ;
7106  PLFLT *arg3 = (PLFLT *) 0 ;
7107  PLFLT *arg4 = (PLFLT *) 0 ;
7108  PLFLT temp1 ;
7109  int res1 = SWIG_TMPOBJ ;
7110  PLFLT temp2 ;
7111  int res2 = SWIG_TMPOBJ ;
7112  PLFLT temp3 ;
7113  int res3 = SWIG_TMPOBJ ;
7114  PLFLT temp4 ;
7115  int res4 = SWIG_TMPOBJ ;
7116 
7117  arg1 = &temp1;
7118  arg2 = &temp2;
7119  arg3 = &temp3;
7120  arg4 = &temp4;
7121  if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7122  plgvpw(arg1,arg2,arg3,arg4);
7123  resultobj = SWIG_Py_Void();
7124  if (SWIG_IsTmpObj(res1)) {
7125  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7126  } else {
7127  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7128  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7129  }
7130  if (SWIG_IsTmpObj(res2)) {
7131  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7132  } else {
7133  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7134  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7135  }
7136  if (SWIG_IsTmpObj(res3)) {
7137  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7138  } else {
7139  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7140  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7141  }
7142  if (SWIG_IsTmpObj(res4)) {
7143  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7144  } else {
7145  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7146  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7147  }
7148  return resultobj;
7149 fail:
7150  return NULL;
7151 }
7152 
7153 
7154 SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7155  PyObject *resultobj = 0;
7156  PLINT *arg1 = (PLINT *) 0 ;
7157  PLINT *arg2 = (PLINT *) 0 ;
7158  PLINT temp1 ;
7159  int res1 = SWIG_TMPOBJ ;
7160  PLINT temp2 ;
7161  int res2 = SWIG_TMPOBJ ;
7162 
7163  arg1 = &temp1;
7164  arg2 = &temp2;
7165  if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7166  plgxax(arg1,arg2);
7167  resultobj = SWIG_Py_Void();
7168  if (SWIG_IsTmpObj(res1)) {
7169  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7170  } else {
7171  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7172  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7173  }
7174  if (SWIG_IsTmpObj(res2)) {
7175  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7176  } else {
7177  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7178  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7179  }
7180  return resultobj;
7181 fail:
7182  return NULL;
7183 }
7184 
7185 
7186 SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7187  PyObject *resultobj = 0;
7188  PLINT *arg1 = (PLINT *) 0 ;
7189  PLINT *arg2 = (PLINT *) 0 ;
7190  PLINT temp1 ;
7191  int res1 = SWIG_TMPOBJ ;
7192  PLINT temp2 ;
7193  int res2 = SWIG_TMPOBJ ;
7194 
7195  arg1 = &temp1;
7196  arg2 = &temp2;
7197  if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7198  plgyax(arg1,arg2);
7199  resultobj = SWIG_Py_Void();
7200  if (SWIG_IsTmpObj(res1)) {
7201  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7202  } else {
7203  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7204  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7205  }
7206  if (SWIG_IsTmpObj(res2)) {
7207  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7208  } else {
7209  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7210  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7211  }
7212  return resultobj;
7213 fail:
7214  return NULL;
7215 }
7216 
7217 
7218 SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7219  PyObject *resultobj = 0;
7220  PLINT *arg1 = (PLINT *) 0 ;
7221  PLINT *arg2 = (PLINT *) 0 ;
7222  PLINT temp1 ;
7223  int res1 = SWIG_TMPOBJ ;
7224  PLINT temp2 ;
7225  int res2 = SWIG_TMPOBJ ;
7226 
7227  arg1 = &temp1;
7228  arg2 = &temp2;
7229  if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7230  plgzax(arg1,arg2);
7231  resultobj = SWIG_Py_Void();
7232  if (SWIG_IsTmpObj(res1)) {
7233  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7234  } else {
7235  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7236  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7237  }
7238  if (SWIG_IsTmpObj(res2)) {
7239  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7240  } else {
7241  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7242  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7243  }
7244  return resultobj;
7245 fail:
7246  return NULL;
7247 }
7248 
7249 
7250 SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251  PyObject *resultobj = 0;
7252  PLINT arg1 ;
7253  PLFLT *arg2 = (PLFLT *) 0 ;
7254  PLFLT arg3 ;
7255  PLFLT arg4 ;
7256  PLINT arg5 ;
7257  PLINT arg6 ;
7258  PyArrayObject *tmp1 = NULL ;
7259  double val3 ;
7260  int ecode3 = 0 ;
7261  double val4 ;
7262  int ecode4 = 0 ;
7263  int val5 ;
7264  int ecode5 = 0 ;
7265  int val6 ;
7266  int ecode6 = 0 ;
7267  PyObject *swig_obj[5] ;
7268 
7269  if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7270  {
7271  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7272  if ( tmp1 == NULL )
7273  return NULL;
7274  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7275  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7276  }
7277  ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7278  if (!SWIG_IsOK(ecode3)) {
7279  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7280  }
7281  arg3 = (PLFLT)(val3);
7282  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7283  if (!SWIG_IsOK(ecode4)) {
7284  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7285  }
7286  arg4 = (PLFLT)(val4);
7287  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7288  if (!SWIG_IsOK(ecode5)) {
7289  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7290  }
7291  arg5 = (PLINT)(val5);
7292  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7293  if (!SWIG_IsOK(ecode6)) {
7294  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7295  }
7296  arg6 = (PLINT)(val6);
7297  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7298  resultobj = SWIG_Py_Void();
7299  {
7300  Py_CLEAR( tmp1 );
7301  }
7302  return resultobj;
7303 fail:
7304  {
7305  Py_CLEAR( tmp1 );
7306  }
7307  return NULL;
7308 }
7309 
7310 
7311 SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7312  PyObject *resultobj = 0;
7313  PLFLT arg1 ;
7314  PLFLT arg2 ;
7315  PLFLT arg3 ;
7316  PLFLT *arg4 = (PLFLT *) 0 ;
7317  PLFLT *arg5 = (PLFLT *) 0 ;
7318  PLFLT *arg6 = (PLFLT *) 0 ;
7319  double val1 ;
7320  int ecode1 = 0 ;
7321  double val2 ;
7322  int ecode2 = 0 ;
7323  double val3 ;
7324  int ecode3 = 0 ;
7325  PLFLT temp4 ;
7326  int res4 = SWIG_TMPOBJ ;
7327  PLFLT temp5 ;
7328  int res5 = SWIG_TMPOBJ ;
7329  PLFLT temp6 ;
7330  int res6 = SWIG_TMPOBJ ;
7331  PyObject *swig_obj[3] ;
7332 
7333  arg4 = &temp4;
7334  arg5 = &temp5;
7335  arg6 = &temp6;
7336  if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7337  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7338  if (!SWIG_IsOK(ecode1)) {
7339  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7340  }
7341  arg1 = (PLFLT)(val1);
7342  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7343  if (!SWIG_IsOK(ecode2)) {
7344  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7345  }
7346  arg2 = (PLFLT)(val2);
7347  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7348  if (!SWIG_IsOK(ecode3)) {
7349  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7350  }
7351  arg3 = (PLFLT)(val3);
7352  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7353  resultobj = SWIG_Py_Void();
7354  if (SWIG_IsTmpObj(res4)) {
7355  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7356  } else {
7357  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7358  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7359  }
7360  if (SWIG_IsTmpObj(res5)) {
7361  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7362  } else {
7363  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7364  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7365  }
7366  if (SWIG_IsTmpObj(res6)) {
7367  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7368  } else {
7369  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7370  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7371  }
7372  return resultobj;
7373 fail:
7374  return NULL;
7375 }
7376 
7377 
7378 SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379  PyObject *resultobj = 0;
7380 
7381  if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7382  plinit();
7383  resultobj = SWIG_Py_Void();
7384  return resultobj;
7385 fail:
7386  return NULL;
7387 }
7388 
7389 
7390 SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7391  PyObject *resultobj = 0;
7392  PLFLT arg1 ;
7393  PLFLT arg2 ;
7394  PLFLT arg3 ;
7395  PLFLT arg4 ;
7396  double val1 ;
7397  int ecode1 = 0 ;
7398  double val2 ;
7399  int ecode2 = 0 ;
7400  double val3 ;
7401  int ecode3 = 0 ;
7402  double val4 ;
7403  int ecode4 = 0 ;
7404  PyObject *swig_obj[4] ;
7405 
7406  if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
7407  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7408  if (!SWIG_IsOK(ecode1)) {
7409  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7410  }
7411  arg1 = (PLFLT)(val1);
7412  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7413  if (!SWIG_IsOK(ecode2)) {
7414  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7415  }
7416  arg2 = (PLFLT)(val2);
7417  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7418  if (!SWIG_IsOK(ecode3)) {
7419  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7420  }
7421  arg3 = (PLFLT)(val3);
7422  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
7423  if (!SWIG_IsOK(ecode4)) {
7424  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7425  }
7426  arg4 = (PLFLT)(val4);
7427  pljoin(arg1,arg2,arg3,arg4);
7428  resultobj = SWIG_Py_Void();
7429  return resultobj;
7430 fail:
7431  return NULL;
7432 }
7433 
7434 
7435 SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7436  PyObject *resultobj = 0;
7437  char *arg1 = (char *) 0 ;
7438  char *arg2 = (char *) 0 ;
7439  char *arg3 = (char *) 0 ;
7440  int res1 ;
7441  char *buf1 = 0 ;
7442  int alloc1 = 0 ;
7443  int res2 ;
7444  char *buf2 = 0 ;
7445  int alloc2 = 0 ;
7446  int res3 ;
7447  char *buf3 = 0 ;
7448  int alloc3 = 0 ;
7449  PyObject *swig_obj[3] ;
7450 
7451  if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
7452  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7453  if (!SWIG_IsOK(res1)) {
7454  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7455  }
7456  arg1 = (char *)(buf1);
7457  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7458  if (!SWIG_IsOK(res2)) {
7459  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7460  }
7461  arg2 = (char *)(buf2);
7462  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7463  if (!SWIG_IsOK(res3)) {
7464  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7465  }
7466  arg3 = (char *)(buf3);
7467  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7468  resultobj = SWIG_Py_Void();
7469  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7470  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7471  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7472  return resultobj;
7473 fail:
7474  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7475  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7476  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7477  return NULL;
7478 }
7479 
7480 
7481 SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7482  PyObject *resultobj = 0;
7483  PLFLT *arg1 = (PLFLT *) 0 ;
7484  PLFLT *arg2 = (PLFLT *) 0 ;
7485  PLINT arg3 ;
7486  PLINT arg4 ;
7487  PLFLT arg5 ;
7488  PLFLT arg6 ;
7489  PLFLT arg7 ;
7490  PLINT arg8 ;
7491  PLINT arg9 ;
7492  PLINT arg10 ;
7493  PLINT arg11 ;
7494  PLINT arg12 ;
7495  PLINT arg13 ;
7496  PLINT *arg14 = (PLINT *) 0 ;
7497  PLFLT arg15 ;
7498  PLFLT arg16 ;
7499  PLFLT arg17 ;
7500  PLFLT arg18 ;
7501  PLINT *arg19 = (PLINT *) 0 ;
7502  char **arg20 = (char **) 0 ;
7503  PLINT *arg21 = (PLINT *) 0 ;
7504  PLINT *arg22 = (PLINT *) 0 ;
7505  PLFLT *arg23 = (PLFLT *) 0 ;
7506  PLFLT *arg24 = (PLFLT *) 0 ;
7507  PLINT *arg25 = (PLINT *) 0 ;
7508  PLINT *arg26 = (PLINT *) 0 ;
7509  PLFLT *arg27 = (PLFLT *) 0 ;
7510  PLINT *arg28 = (PLINT *) 0 ;
7511  PLFLT *arg29 = (PLFLT *) 0 ;
7512  PLINT *arg30 = (PLINT *) 0 ;
7513  char **arg31 = (char **) 0 ;
7514  PLFLT temp1 ;
7515  int res1 = SWIG_TMPOBJ ;
7516  PLFLT temp2 ;
7517  int res2 = SWIG_TMPOBJ ;
7518  int val3 ;
7519  int ecode3 = 0 ;
7520  int val4 ;
7521  int ecode4 = 0 ;
7522  double val5 ;
7523  int ecode5 = 0 ;
7524  double val6 ;
7525  int ecode6 = 0 ;
7526  double val7 ;
7527  int ecode7 = 0 ;
7528  int val8 ;
7529  int ecode8 = 0 ;
7530  int val9 ;
7531  int ecode9 = 0 ;
7532  int val10 ;
7533  int ecode10 = 0 ;
7534  int val11 ;
7535  int ecode11 = 0 ;
7536  int val12 ;
7537  int ecode12 = 0 ;
7538  PyArrayObject *tmp13 = NULL ;
7539  double val15 ;
7540  int ecode15 = 0 ;
7541  double val16 ;
7542  int ecode16 = 0 ;
7543  double val17 ;
7544  int ecode17 = 0 ;
7545  double val18 ;
7546  int ecode18 = 0 ;
7547  PyArrayObject *tmp19 = NULL ;
7548  PyArrayObject *tmp20 = NULL ;
7549  PyArrayObject *tmp21 = NULL ;
7550  PyArrayObject *tmp22 = NULL ;
7551  PyArrayObject *tmp23 = NULL ;
7552  PyArrayObject *tmp24 = NULL ;
7553  PyArrayObject *tmp25 = NULL ;
7554  PyArrayObject *tmp26 = NULL ;
7555  PyArrayObject *tmp27 = NULL ;
7556  PyArrayObject *tmp28 = NULL ;
7557  PyArrayObject *tmp29 = NULL ;
7558  PyArrayObject *tmp30 = NULL ;
7559  PyArrayObject *tmp31 = NULL ;
7560  PyObject *swig_obj[28] ;
7561 
7562  arg1 = &temp1;
7563  arg2 = &temp2;
7564  if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
7565  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
7566  if (!SWIG_IsOK(ecode3)) {
7567  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7568  }
7569  arg3 = (PLINT)(val3);
7570  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
7571  if (!SWIG_IsOK(ecode4)) {
7572  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7573  }
7574  arg4 = (PLINT)(val4);
7575  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
7576  if (!SWIG_IsOK(ecode5)) {
7577  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7578  }
7579  arg5 = (PLFLT)(val5);
7580  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
7581  if (!SWIG_IsOK(ecode6)) {
7582  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7583  }
7584  arg6 = (PLFLT)(val6);
7585  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
7586  if (!SWIG_IsOK(ecode7)) {
7587  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7588  }
7589  arg7 = (PLFLT)(val7);
7590  ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
7591  if (!SWIG_IsOK(ecode8)) {
7592  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7593  }
7594  arg8 = (PLINT)(val8);
7595  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
7596  if (!SWIG_IsOK(ecode9)) {
7597  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7598  }
7599  arg9 = (PLINT)(val9);
7600  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
7601  if (!SWIG_IsOK(ecode10)) {
7602  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7603  }
7604  arg10 = (PLINT)(val10);
7605  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
7606  if (!SWIG_IsOK(ecode11)) {
7607  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7608  }
7609  arg11 = (PLINT)(val11);
7610  ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
7611  if (!SWIG_IsOK(ecode12)) {
7612  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7613  }
7614  arg12 = (PLINT)(val12);
7615  {
7616  tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
7617  if ( tmp13 == NULL )
7618  return NULL;
7619  arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7620  arg14 = (PLINT *) PyArray_DATA( tmp13 );
7621  }
7622  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
7623  if (!SWIG_IsOK(ecode15)) {
7624  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7625  }
7626  arg15 = (PLFLT)(val15);
7627  ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
7628  if (!SWIG_IsOK(ecode16)) {
7629  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7630  }
7631  arg16 = (PLFLT)(val16);
7632  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
7633  if (!SWIG_IsOK(ecode17)) {
7634  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7635  }
7636  arg17 = (PLFLT)(val17);
7637  ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
7638  if (!SWIG_IsOK(ecode18)) {
7639  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7640  }
7641  arg18 = (PLFLT)(val18);
7642  {
7643  tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
7644  if ( tmp19 == NULL )
7645  return NULL;
7646  if ( PyArray_DIMS( tmp19 )[0] != Alen )
7647  {
7648  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7649  return NULL;
7650  }
7651  arg19 = (PLINT *) PyArray_DATA( tmp19 );
7652  }
7653  {
7654  int i;
7655  tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
7656  if ( tmp20 == NULL )
7657  return NULL;
7658  if ( PyArray_DIMS( tmp20 )[0] != Alen )
7659  {
7660  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7661  return NULL;
7662  }
7663  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7664  for ( i = 0; i < Alen; i++ )
7665  {
7666  arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7667  if ( arg20[i] == NULL )
7668  {
7669  free( arg20 );
7670  return NULL;
7671  }
7672  }
7673  }
7674  {
7675  tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
7676  if ( tmp21 == NULL )
7677  return NULL;
7678  if ( PyArray_DIMS( tmp21 )[0] != Alen )
7679  {
7680  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7681  return NULL;
7682  }
7683  arg21 = (PLINT *) PyArray_DATA( tmp21 );
7684  }
7685  {
7686  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
7687  if ( tmp22 == NULL )
7688  return NULL;
7689  if ( PyArray_DIMS( tmp22 )[0] != Alen )
7690  {
7691  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7692  return NULL;
7693  }
7694  arg22 = (PLINT *) PyArray_DATA( tmp22 );
7695  }
7696  {
7697  if ( swig_obj[19] != Py_None )
7698  {
7699  tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
7700  if ( tmp23 == NULL )
7701  return NULL;
7702  if ( PyArray_DIMS( tmp23 )[0] != Alen )
7703  {
7704  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7705  return NULL;
7706  }
7707  arg23 = (PLFLT *) PyArray_DATA( tmp23 );
7708  }
7709  else
7710  {
7711  arg23 = NULL;
7712  }
7713  }
7714  {
7715  if ( swig_obj[20] != Py_None )
7716  {
7717  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
7718  if ( tmp24 == NULL )
7719  return NULL;
7720  if ( PyArray_DIMS( tmp24 )[0] != Alen )
7721  {
7722  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7723  return NULL;
7724  }
7725  arg24 = (PLFLT *) PyArray_DATA( tmp24 );
7726  }
7727  else
7728  {
7729  arg24 = NULL;
7730  }
7731  }
7732  {
7733  tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
7734  if ( tmp25 == NULL )
7735  return NULL;
7736  if ( PyArray_DIMS( tmp25 )[0] != Alen )
7737  {
7738  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7739  return NULL;
7740  }
7741  arg25 = (PLINT *) PyArray_DATA( tmp25 );
7742  }
7743  {
7744  tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
7745  if ( tmp26 == NULL )
7746  return NULL;
7747  if ( PyArray_DIMS( tmp26 )[0] != Alen )
7748  {
7749  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7750  return NULL;
7751  }
7752  arg26 = (PLINT *) PyArray_DATA( tmp26 );
7753  }
7754  {
7755  if ( swig_obj[23] != Py_None )
7756  {
7757  tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
7758  if ( tmp27 == NULL )
7759  return NULL;
7760  if ( PyArray_DIMS( tmp27 )[0] != Alen )
7761  {
7762  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7763  return NULL;
7764  }
7765  arg27 = (PLFLT *) PyArray_DATA( tmp27 );
7766  }
7767  else
7768  {
7769  arg27 = NULL;
7770  }
7771  }
7772  {
7773  tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
7774  if ( tmp28 == NULL )
7775  return NULL;
7776  if ( PyArray_DIMS( tmp28 )[0] != Alen )
7777  {
7778  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7779  return NULL;
7780  }
7781  arg28 = (PLINT *) PyArray_DATA( tmp28 );
7782  }
7783  {
7784  if ( swig_obj[25] != Py_None )
7785  {
7786  tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
7787  if ( tmp29 == NULL )
7788  return NULL;
7789  if ( PyArray_DIMS( tmp29 )[0] != Alen )
7790  {
7791  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7792  return NULL;
7793  }
7794  arg29 = (PLFLT *) PyArray_DATA( tmp29 );
7795  }
7796  else
7797  {
7798  arg29 = NULL;
7799  }
7800  }
7801  {
7802  tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
7803  if ( tmp30 == NULL )
7804  return NULL;
7805  if ( PyArray_DIMS( tmp30 )[0] != Alen )
7806  {
7807  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7808  return NULL;
7809  }
7810  arg30 = (PLINT *) PyArray_DATA( tmp30 );
7811  }
7812  {
7813  int i;
7814  tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
7815  if ( tmp31 == NULL )
7816  return NULL;
7817  if ( PyArray_DIMS( tmp31 )[0] != Alen )
7818  {
7819  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7820  return NULL;
7821  }
7822  arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7823  for ( i = 0; i < Alen; i++ )
7824  {
7825  arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
7826  if ( arg31[i] == NULL )
7827  {
7828  free( arg31 );
7829  return NULL;
7830  }
7831  }
7832  }
7833  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);
7834  resultobj = SWIG_Py_Void();
7835  if (SWIG_IsTmpObj(res1)) {
7836  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7837  } else {
7838  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7839  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7840  }
7841  if (SWIG_IsTmpObj(res2)) {
7842  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7843  } else {
7844  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7845  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7846  }
7847  {
7848  Py_CLEAR( tmp13 );
7849  }
7850  {
7851  Py_CLEAR( tmp19 );
7852  }
7853  {
7854  Py_CLEAR( tmp20 ); free( arg20 );
7855  }
7856  {
7857  Py_CLEAR( tmp21 );
7858  }
7859  {
7860  Py_CLEAR( tmp22 );
7861  }
7862  {
7863  Py_CLEAR( tmp23 );
7864  }
7865  {
7866  Py_CLEAR( tmp24 );
7867  }
7868  {
7869  Py_CLEAR( tmp25 );
7870  }
7871  {
7872  Py_CLEAR( tmp26 );
7873  }
7874  {
7875  Py_CLEAR( tmp27 );
7876  }
7877  {
7878  Py_CLEAR( tmp28 );
7879  }
7880  {
7881  Py_CLEAR( tmp29 );
7882  }
7883  {
7884  Py_CLEAR( tmp30 );
7885  }
7886  {
7887  Py_CLEAR( tmp31 ); free( arg31 );
7888  }
7889  return resultobj;
7890 fail:
7891  {
7892  Py_CLEAR( tmp13 );
7893  }
7894  {
7895  Py_CLEAR( tmp19 );
7896  }
7897  {
7898  Py_CLEAR( tmp20 ); free( arg20 );
7899  }
7900  {
7901  Py_CLEAR( tmp21 );
7902  }
7903  {
7904  Py_CLEAR( tmp22 );
7905  }
7906  {
7907  Py_CLEAR( tmp23 );
7908  }
7909  {
7910  Py_CLEAR( tmp24 );
7911  }
7912  {
7913  Py_CLEAR( tmp25 );
7914  }
7915  {
7916  Py_CLEAR( tmp26 );
7917  }
7918  {
7919  Py_CLEAR( tmp27 );
7920  }
7921  {
7922  Py_CLEAR( tmp28 );
7923  }
7924  {
7925  Py_CLEAR( tmp29 );
7926  }
7927  {
7928  Py_CLEAR( tmp30 );
7929  }
7930  {
7931  Py_CLEAR( tmp31 ); free( arg31 );
7932  }
7933  return NULL;
7934 }
7935 
7936 
7937 SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7938  PyObject *resultobj = 0;
7939  PLFLT *arg1 = (PLFLT *) 0 ;
7940  PLFLT *arg2 = (PLFLT *) 0 ;
7941  PLINT arg3 ;
7942  PLINT arg4 ;
7943  PLFLT arg5 ;
7944  PLFLT arg6 ;
7945  PLFLT arg7 ;
7946  PLFLT arg8 ;
7947  PLINT arg9 ;
7948  PLINT arg10 ;
7949  PLINT arg11 ;
7950  PLFLT arg12 ;
7951  PLFLT arg13 ;
7952  PLINT arg14 ;
7953  PLFLT arg15 ;
7954  PLINT arg16 ;
7955  PLINT *arg17 = (PLINT *) 0 ;
7956  char **arg18 = (char **) 0 ;
7957  PLINT arg19 ;
7958  char **arg20 = (char **) 0 ;
7959  PLFLT *arg21 = (PLFLT *) 0 ;
7960  PLINT *arg22 = (PLINT *) 0 ;
7961  PLINT *arg23 = (PLINT *) 0 ;
7962  PLFLT **arg24 = (PLFLT **) 0 ;
7963  PLFLT temp1 ;
7964  int res1 = SWIG_TMPOBJ ;
7965  PLFLT temp2 ;
7966  int res2 = SWIG_TMPOBJ ;
7967  int val3 ;
7968  int ecode3 = 0 ;
7969  int val4 ;
7970  int ecode4 = 0 ;
7971  double val5 ;
7972  int ecode5 = 0 ;
7973  double val6 ;
7974  int ecode6 = 0 ;
7975  double val7 ;
7976  int ecode7 = 0 ;
7977  double val8 ;
7978  int ecode8 = 0 ;
7979  int val9 ;
7980  int ecode9 = 0 ;
7981  int val10 ;
7982  int ecode10 = 0 ;
7983  int val11 ;
7984  int ecode11 = 0 ;
7985  double val12 ;
7986  int ecode12 = 0 ;
7987  double val13 ;
7988  int ecode13 = 0 ;
7989  int val14 ;
7990  int ecode14 = 0 ;
7991  double val15 ;
7992  int ecode15 = 0 ;
7993  PyArrayObject *tmp16 = NULL ;
7994  PyArrayObject *tmp18 = NULL ;
7995  PyArrayObject *tmp19 = NULL ;
7996  PyArrayObject *tmp21 = NULL ;
7997  PyArrayObject *tmp22 = NULL ;
7998  PyArrayObject *tmp23 = NULL ;
7999  PyArrayObject *tmp24 = NULL ;
8000  PyObject *swig_obj[20] ;
8001 
8002  arg1 = &temp1;
8003  arg2 = &temp2;
8004  if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8005  ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8006  if (!SWIG_IsOK(ecode3)) {
8007  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8008  }
8009  arg3 = (PLINT)(val3);
8010  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8011  if (!SWIG_IsOK(ecode4)) {
8012  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8013  }
8014  arg4 = (PLINT)(val4);
8015  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8016  if (!SWIG_IsOK(ecode5)) {
8017  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8018  }
8019  arg5 = (PLFLT)(val5);
8020  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8021  if (!SWIG_IsOK(ecode6)) {
8022  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8023  }
8024  arg6 = (PLFLT)(val6);
8025  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8026  if (!SWIG_IsOK(ecode7)) {
8027  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8028  }
8029  arg7 = (PLFLT)(val7);
8030  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8031  if (!SWIG_IsOK(ecode8)) {
8032  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8033  }
8034  arg8 = (PLFLT)(val8);
8035  ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8036  if (!SWIG_IsOK(ecode9)) {
8037  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8038  }
8039  arg9 = (PLINT)(val9);
8040  ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8041  if (!SWIG_IsOK(ecode10)) {
8042  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8043  }
8044  arg10 = (PLINT)(val10);
8045  ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8046  if (!SWIG_IsOK(ecode11)) {
8047  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8048  }
8049  arg11 = (PLINT)(val11);
8050  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8051  if (!SWIG_IsOK(ecode12)) {
8052  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8053  }
8054  arg12 = (PLFLT)(val12);
8055  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8056  if (!SWIG_IsOK(ecode13)) {
8057  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8058  }
8059  arg13 = (PLFLT)(val13);
8060  ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8061  if (!SWIG_IsOK(ecode14)) {
8062  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8063  }
8064  arg14 = (PLINT)(val14);
8065  ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8066  if (!SWIG_IsOK(ecode15)) {
8067  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8068  }
8069  arg15 = (PLFLT)(val15);
8070  {
8071  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8072  if ( tmp16 == NULL )
8073  return NULL;
8074  arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8075  arg17 = (PLINT *) PyArray_DATA( tmp16 );
8076  }
8077  {
8078  int i;
8079  tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8080  if ( tmp18 == NULL )
8081  return NULL;
8082  if ( PyArray_DIMS( tmp18 )[0] != Alen )
8083  {
8084  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8085  return NULL;
8086  }
8087  arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8088  for ( i = 0; i < Alen; i++ )
8089  {
8090  arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8091  if ( arg18[i] == NULL )
8092  {
8093  free( arg18 );
8094  return NULL;
8095  }
8096  }
8097  }
8098  {
8099  int i;
8100  tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8101  if ( tmp19 == NULL )
8102  return NULL;
8103  Alen = PyArray_DIMS( tmp19 )[0];
8104  arg19 = Alen;
8105  arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8106  for ( i = 0; i < Alen; i++ )
8107  {
8108  arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8109  if ( arg20[i] == NULL )
8110  {
8111  free( arg20 );
8112  return NULL;
8113  }
8114  }
8115  }
8116  {
8117  tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8118  if ( tmp21 == NULL )
8119  return NULL;
8120  if ( PyArray_DIMS( tmp21 )[0] != Alen )
8121  {
8122  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8123  return NULL;
8124  }
8125  arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8126  }
8127  {
8128  tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8129  if ( tmp22 == NULL )
8130  return NULL;
8131  if ( PyArray_DIMS( tmp22 )[0] != Alen )
8132  {
8133  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8134  return NULL;
8135  }
8136  arg22 = (PLINT *) PyArray_DATA( tmp22 );
8137  }
8138  {
8139  int i;
8140  tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8141  if ( tmp23 == NULL )
8142  return NULL;
8143  if ( PyArray_DIMS( tmp23 )[0] != Alen )
8144  {
8145  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8146  return NULL;
8147  }
8148  Xlen = PyArray_DIMS( tmp23 )[0];
8149  arg23 = (PLINT *) PyArray_DATA( tmp23 );
8150  Ylen = -1;
8151  for ( i = 0; i < Xlen; i++ )
8152  if ( arg23[i] > Ylen )
8153  Ylen = arg23[i];
8154  }
8155  {
8156  int i, size;
8157  tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8158  if ( tmp24 == NULL )
8159  return NULL;
8160  if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8161  {
8162  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8163  return NULL;
8164  }
8165  size = Ylen;
8166  arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8167  for ( i = 0; i < Xlen; i++ )
8168  arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8169  }
8170  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);
8171  resultobj = SWIG_Py_Void();
8172  if (SWIG_IsTmpObj(res1)) {
8173  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8174  } else {
8175  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8176  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8177  }
8178  if (SWIG_IsTmpObj(res2)) {
8179  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8180  } else {
8181  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8182  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8183  }
8184  {
8185  Py_CLEAR( tmp16 );
8186  }
8187  {
8188  Py_CLEAR( tmp18 ); free( arg18 );
8189  }
8190  {
8191  Py_CLEAR( tmp19 ); free( arg20 );
8192  }
8193  {
8194  Py_CLEAR( tmp21 );
8195  }
8196  {
8197  Py_CLEAR( tmp22 );
8198  }
8199  {
8200  Py_CLEAR( tmp23 );
8201  }
8202  {
8203  Py_CLEAR( tmp24 );
8204  free( arg24 );
8205  }
8206  return resultobj;
8207 fail:
8208  {
8209  Py_CLEAR( tmp16 );
8210  }
8211  {
8212  Py_CLEAR( tmp18 ); free( arg18 );
8213  }
8214  {
8215  Py_CLEAR( tmp19 ); free( arg20 );
8216  }
8217  {
8218  Py_CLEAR( tmp21 );
8219  }
8220  {
8221  Py_CLEAR( tmp22 );
8222  }
8223  {
8224  Py_CLEAR( tmp23 );
8225  }
8226  {
8227  Py_CLEAR( tmp24 );
8228  free( arg24 );
8229  }
8230  return NULL;
8231 }
8232 
8233 
8234 SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8235  PyObject *resultobj = 0;
8236  PLFLT arg1 ;
8237  PLFLT arg2 ;
8238  PLFLT arg3 ;
8239  double val1 ;
8240  int ecode1 = 0 ;
8241  double val2 ;
8242  int ecode2 = 0 ;
8243  double val3 ;
8244  int ecode3 = 0 ;
8245  PyObject *swig_obj[3] ;
8246 
8247  if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8248  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8249  if (!SWIG_IsOK(ecode1)) {
8250  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8251  }
8252  arg1 = (PLFLT)(val1);
8253  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8254  if (!SWIG_IsOK(ecode2)) {
8255  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8256  }
8257  arg2 = (PLFLT)(val2);
8258  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8259  if (!SWIG_IsOK(ecode3)) {
8260  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8261  }
8262  arg3 = (PLFLT)(val3);
8263  pllightsource(arg1,arg2,arg3);
8264  resultobj = SWIG_Py_Void();
8265  return resultobj;
8266 fail:
8267  return NULL;
8268 }
8269 
8270 
8271 SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8272  PyObject *resultobj = 0;
8273  PLINT arg1 ;
8274  PLFLT *arg2 = (PLFLT *) 0 ;
8275  PLFLT *arg3 = (PLFLT *) 0 ;
8276  PyArrayObject *tmp1 = NULL ;
8277  PyArrayObject *tmp3 = NULL ;
8278  PyObject *swig_obj[2] ;
8279 
8280  if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8281  {
8282  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8283  if ( tmp1 == NULL )
8284  return NULL;
8285  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8286  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8287  }
8288  {
8289  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8290  if ( tmp3 == NULL )
8291  return NULL;
8292  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8293  {
8294  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8295  return NULL;
8296  }
8297  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8298  }
8299  plline(arg1,(double const *)arg2,(double const *)arg3);
8300  resultobj = SWIG_Py_Void();
8301  {
8302  Py_CLEAR( tmp1 );
8303  }
8304  {
8305  Py_CLEAR( tmp3 );
8306  }
8307  return resultobj;
8308 fail:
8309  {
8310  Py_CLEAR( tmp1 );
8311  }
8312  {
8313  Py_CLEAR( tmp3 );
8314  }
8315  return NULL;
8316 }
8317 
8318 
8319 SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8320  PyObject *resultobj = 0;
8321  PLINT arg1 ;
8322  PLFLT *arg2 = (PLFLT *) 0 ;
8323  PLFLT *arg3 = (PLFLT *) 0 ;
8324  PLFLT *arg4 = (PLFLT *) 0 ;
8325  PyArrayObject *tmp1 = NULL ;
8326  PyArrayObject *tmp3 = NULL ;
8327  PyArrayObject *tmp4 = NULL ;
8328  PyObject *swig_obj[3] ;
8329 
8330  if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8331  {
8332  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8333  if ( tmp1 == NULL )
8334  return NULL;
8335  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8336  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8337  }
8338  {
8339  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8340  if ( tmp3 == NULL )
8341  return NULL;
8342  if ( PyArray_DIMS( tmp3 )[0] != Alen )
8343  {
8344  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8345  return NULL;
8346  }
8347  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8348  }
8349  {
8350  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8351  if ( tmp4 == NULL )
8352  return NULL;
8353  if ( PyArray_DIMS( tmp4 )[0] != Alen )
8354  {
8355  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8356  return NULL;
8357  }
8358  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8359  }
8360  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8361  resultobj = SWIG_Py_Void();
8362  {
8363  Py_CLEAR( tmp1 );
8364  }
8365  {
8366  Py_CLEAR( tmp3 );
8367  }
8368  {
8369  Py_CLEAR( tmp4 );
8370  }
8371  return resultobj;
8372 fail:
8373  {
8374  Py_CLEAR( tmp1 );
8375  }
8376  {
8377  Py_CLEAR( tmp3 );
8378  }
8379  {
8380  Py_CLEAR( tmp4 );
8381  }
8382  return NULL;
8383 }
8384 
8385 
8386 SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387  PyObject *resultobj = 0;
8388  PLINT arg1 ;
8389  int val1 ;
8390  int ecode1 = 0 ;
8391  PyObject *swig_obj[1] ;
8392 
8393  if (!args) SWIG_fail;
8394  swig_obj[0] = args;
8395  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
8396  if (!SWIG_IsOK(ecode1)) {
8397  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8398  }
8399  arg1 = (PLINT)(val1);
8400  pllsty(arg1);
8401  resultobj = SWIG_Py_Void();
8402  return resultobj;
8403 fail:
8404  return NULL;
8405 }
8406 
8407 
8408 SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8409  PyObject *resultobj = 0;
8410  PLFLT *arg1 = (PLFLT *) 0 ;
8411  PLFLT *arg2 = (PLFLT *) 0 ;
8412  PLFLT **arg3 = (PLFLT **) 0 ;
8413  PLINT arg4 ;
8414  PLINT arg5 ;
8415  PLINT arg6 ;
8416  PyArrayObject *tmp1 = NULL ;
8417  PyArrayObject *tmp2 = NULL ;
8418  PyArrayObject *tmp3 = NULL ;
8419  int val6 ;
8420  int ecode6 = 0 ;
8421  PyObject *swig_obj[4] ;
8422 
8423  if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
8424  {
8425  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8426  if ( tmp1 == NULL )
8427  return NULL;
8428  Xlen = PyArray_DIMS( tmp1 )[0];
8429  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8430  }
8431  {
8432  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8433  if ( tmp2 == NULL )
8434  return NULL;
8435  Ylen = PyArray_DIMS( tmp2 )[0];
8436  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8437  }
8438  {
8439  int i, size;
8440  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8441  if ( tmp3 == NULL )
8442  return NULL;
8443  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8444  {
8445  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8446  return NULL;
8447  }
8448  arg4 = PyArray_DIMS( tmp3 )[0];
8449  arg5 = PyArray_DIMS( tmp3 )[1];
8450  size = arg5;
8451  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8452  for ( i = 0; i < arg4; i++ )
8453  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8454  }
8455  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8456  if (!SWIG_IsOK(ecode6)) {
8457  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8458  }
8459  arg6 = (PLINT)(val6);
8460  plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8461  resultobj = SWIG_Py_Void();
8462  {
8463  Py_CLEAR( tmp1 );
8464  }
8465  {
8466  Py_CLEAR( tmp2 );
8467  }
8468  {
8469  Py_CLEAR( tmp3 );
8470  free( arg3 );
8471  }
8472  return resultobj;
8473 fail:
8474  {
8475  Py_CLEAR( tmp1 );
8476  }
8477  {
8478  Py_CLEAR( tmp2 );
8479  }
8480  {
8481  Py_CLEAR( tmp3 );
8482  free( arg3 );
8483  }
8484  return NULL;
8485 }
8486 
8487 
8488 SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489  PyObject *resultobj = 0;
8490  PLFLT *arg1 = (PLFLT *) 0 ;
8491  PLFLT *arg2 = (PLFLT *) 0 ;
8492  PLFLT **arg3 = (PLFLT **) 0 ;
8493  PLINT arg4 ;
8494  PLINT arg5 ;
8495  PLINT arg6 ;
8496  PLFLT *arg7 = (PLFLT *) 0 ;
8497  PLINT arg8 ;
8498  PyArrayObject *tmp1 = NULL ;
8499  PyArrayObject *tmp2 = NULL ;
8500  PyArrayObject *tmp3 = NULL ;
8501  int val6 ;
8502  int ecode6 = 0 ;
8503  PyArrayObject *tmp7 = NULL ;
8504  PyObject *swig_obj[5] ;
8505 
8506  if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
8507  {
8508  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8509  if ( tmp1 == NULL )
8510  return NULL;
8511  Xlen = PyArray_DIMS( tmp1 )[0];
8512  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8513  }
8514  {
8515  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8516  if ( tmp2 == NULL )
8517  return NULL;
8518  Ylen = PyArray_DIMS( tmp2 )[0];
8519  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8520  }
8521  {
8522  int i, size;
8523  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8524  if ( tmp3 == NULL )
8525  return NULL;
8526  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8527  {
8528  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8529  return NULL;
8530  }
8531  arg4 = PyArray_DIMS( tmp3 )[0];
8532  arg5 = PyArray_DIMS( tmp3 )[1];
8533  size = arg5;
8534  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8535  for ( i = 0; i < arg4; i++ )
8536  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8537  }
8538  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8539  if (!SWIG_IsOK(ecode6)) {
8540  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8541  }
8542  arg6 = (PLINT)(val6);
8543  {
8544  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8545  if ( tmp7 == NULL )
8546  return NULL;
8547  arg8 = PyArray_DIMS( tmp7 )[0];
8548  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8549  }
8550  plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8551  resultobj = SWIG_Py_Void();
8552  {
8553  Py_CLEAR( tmp1 );
8554  }
8555  {
8556  Py_CLEAR( tmp2 );
8557  }
8558  {
8559  Py_CLEAR( tmp3 );
8560  free( arg3 );
8561  }
8562  {
8563  Py_CLEAR( tmp7 );
8564  }
8565  return resultobj;
8566 fail:
8567  {
8568  Py_CLEAR( tmp1 );
8569  }
8570  {
8571  Py_CLEAR( tmp2 );
8572  }
8573  {
8574  Py_CLEAR( tmp3 );
8575  free( arg3 );
8576  }
8577  {
8578  Py_CLEAR( tmp7 );
8579  }
8580  return NULL;
8581 }
8582 
8583 
8584 SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8585  PyObject *resultobj = 0;
8586  PLINT *arg1 = (PLINT *) 0 ;
8587  PLINT temp1 ;
8588  int res1 = SWIG_TMPOBJ ;
8589 
8590  arg1 = &temp1;
8591  if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
8592  plmkstrm(arg1);
8593  resultobj = SWIG_Py_Void();
8594  if (SWIG_IsTmpObj(res1)) {
8595  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8596  } else {
8597  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8598  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8599  }
8600  return resultobj;
8601 fail:
8602  return NULL;
8603 }
8604 
8605 
8606 SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8607  PyObject *resultobj = 0;
8608  char *arg1 = (char *) 0 ;
8609  PLFLT arg2 ;
8610  PLFLT arg3 ;
8611  PLFLT arg4 ;
8612  char *arg5 = (char *) 0 ;
8613  int res1 ;
8614  char *buf1 = 0 ;
8615  int alloc1 = 0 ;
8616  double val2 ;
8617  int ecode2 = 0 ;
8618  double val3 ;
8619  int ecode3 = 0 ;
8620  double val4 ;
8621  int ecode4 = 0 ;
8622  int res5 ;
8623  char *buf5 = 0 ;
8624  int alloc5 = 0 ;
8625  PyObject *swig_obj[5] ;
8626 
8627  if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
8628  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8629  if (!SWIG_IsOK(res1)) {
8630  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8631  }
8632  arg1 = (char *)(buf1);
8633  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8634  if (!SWIG_IsOK(ecode2)) {
8635  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8636  }
8637  arg2 = (PLFLT)(val2);
8638  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8639  if (!SWIG_IsOK(ecode3)) {
8640  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8641  }
8642  arg3 = (PLFLT)(val3);
8643  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8644  if (!SWIG_IsOK(ecode4)) {
8645  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8646  }
8647  arg4 = (PLFLT)(val4);
8648  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8649  if (!SWIG_IsOK(res5)) {
8650  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8651  }
8652  arg5 = (char *)(buf5);
8653  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8654  resultobj = SWIG_Py_Void();
8655  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8656  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8657  return resultobj;
8658 fail:
8659  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8660  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8661  return NULL;
8662 }
8663 
8664 
8665 SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8666  PyObject *resultobj = 0;
8667  char *arg1 = (char *) 0 ;
8668  PLFLT arg2 ;
8669  PLFLT arg3 ;
8670  PLFLT arg4 ;
8671  char *arg5 = (char *) 0 ;
8672  int res1 ;
8673  char *buf1 = 0 ;
8674  int alloc1 = 0 ;
8675  double val2 ;
8676  int ecode2 = 0 ;
8677  double val3 ;
8678  int ecode3 = 0 ;
8679  double val4 ;
8680  int ecode4 = 0 ;
8681  int res5 ;
8682  char *buf5 = 0 ;
8683  int alloc5 = 0 ;
8684  PyObject *swig_obj[5] ;
8685 
8686  if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
8687  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8688  if (!SWIG_IsOK(res1)) {
8689  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
8690  }
8691  arg1 = (char *)(buf1);
8692  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8693  if (!SWIG_IsOK(ecode2)) {
8694  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
8695  }
8696  arg2 = (PLFLT)(val2);
8697  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8698  if (!SWIG_IsOK(ecode3)) {
8699  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
8700  }
8701  arg3 = (PLFLT)(val3);
8702  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8703  if (!SWIG_IsOK(ecode4)) {
8704  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
8705  }
8706  arg4 = (PLFLT)(val4);
8707  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8708  if (!SWIG_IsOK(res5)) {
8709  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
8710  }
8711  arg5 = (char *)(buf5);
8712  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8713  resultobj = SWIG_Py_Void();
8714  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8715  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8716  return resultobj;
8717 fail:
8718  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8719  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8720  return NULL;
8721 }
8722 
8723 
8724 SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725  PyObject *resultobj = 0;
8726  PLFLT *arg1 = (PLFLT *) 0 ;
8727  PLFLT *arg2 = (PLFLT *) 0 ;
8728  PLFLT **arg3 = (PLFLT **) 0 ;
8729  PLINT arg4 ;
8730  PLINT arg5 ;
8731  PLINT arg6 ;
8732  PLBOOL arg7 ;
8733  PyArrayObject *tmp1 = NULL ;
8734  PyArrayObject *tmp2 = NULL ;
8735  PyArrayObject *tmp3 = NULL ;
8736  int val6 ;
8737  int ecode6 = 0 ;
8738  int val7 ;
8739  int ecode7 = 0 ;
8740  PyObject *swig_obj[5] ;
8741 
8742  if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
8743  {
8744  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8745  if ( tmp1 == NULL )
8746  return NULL;
8747  Xlen = PyArray_DIMS( tmp1 )[0];
8748  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8749  }
8750  {
8751  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8752  if ( tmp2 == NULL )
8753  return NULL;
8754  Ylen = PyArray_DIMS( tmp2 )[0];
8755  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8756  }
8757  {
8758  int i, size;
8759  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8760  if ( tmp3 == NULL )
8761  return NULL;
8762  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8763  {
8764  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8765  return NULL;
8766  }
8767  arg4 = PyArray_DIMS( tmp3 )[0];
8768  arg5 = PyArray_DIMS( tmp3 )[1];
8769  size = arg5;
8770  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8771  for ( i = 0; i < arg4; i++ )
8772  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8773  }
8774  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8775  if (!SWIG_IsOK(ecode6)) {
8776  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
8777  }
8778  arg6 = (PLINT)(val6);
8779  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
8780  if (!SWIG_IsOK(ecode7)) {
8781  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
8782  }
8783  arg7 = (PLBOOL)(val7);
8784  plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
8785  resultobj = SWIG_Py_Void();
8786  {
8787  Py_CLEAR( tmp1 );
8788  }
8789  {
8790  Py_CLEAR( tmp2 );
8791  }
8792  {
8793  Py_CLEAR( tmp3 );
8794  free( arg3 );
8795  }
8796  return resultobj;
8797 fail:
8798  {
8799  Py_CLEAR( tmp1 );
8800  }
8801  {
8802  Py_CLEAR( tmp2 );
8803  }
8804  {
8805  Py_CLEAR( tmp3 );
8806  free( arg3 );
8807  }
8808  return NULL;
8809 }
8810 
8811 
8812 SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8813  PyObject *resultobj = 0;
8814  PLFLT *arg1 = (PLFLT *) 0 ;
8815  PLFLT *arg2 = (PLFLT *) 0 ;
8816  PLFLT **arg3 = (PLFLT **) 0 ;
8817  PLINT arg4 ;
8818  PLINT arg5 ;
8819  PLINT arg6 ;
8820  PLFLT *arg7 = (PLFLT *) 0 ;
8821  PLINT arg8 ;
8822  PyArrayObject *tmp1 = NULL ;
8823  PyArrayObject *tmp2 = NULL ;
8824  PyArrayObject *tmp3 = NULL ;
8825  int val6 ;
8826  int ecode6 = 0 ;
8827  PyArrayObject *tmp7 = NULL ;
8828  PyObject *swig_obj[5] ;
8829 
8830  if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
8831  {
8832  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8833  if ( tmp1 == NULL )
8834  return NULL;
8835  Xlen = PyArray_DIMS( tmp1 )[0];
8836  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8837  }
8838  {
8839  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8840  if ( tmp2 == NULL )
8841  return NULL;
8842  Ylen = PyArray_DIMS( tmp2 )[0];
8843  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8844  }
8845  {
8846  int i, size;
8847  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8848  if ( tmp3 == NULL )
8849  return NULL;
8850  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8851  {
8852  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8853  return NULL;
8854  }
8855  arg4 = PyArray_DIMS( tmp3 )[0];
8856  arg5 = PyArray_DIMS( tmp3 )[1];
8857  size = arg5;
8858  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8859  for ( i = 0; i < arg4; i++ )
8860  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8861  }
8862  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8863  if (!SWIG_IsOK(ecode6)) {
8864  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
8865  }
8866  arg6 = (PLINT)(val6);
8867  {
8868  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8869  if ( tmp7 == NULL )
8870  return NULL;
8871  arg8 = PyArray_DIMS( tmp7 )[0];
8872  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8873  }
8874  plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8875  resultobj = SWIG_Py_Void();
8876  {
8877  Py_CLEAR( tmp1 );
8878  }
8879  {
8880  Py_CLEAR( tmp2 );
8881  }
8882  {
8883  Py_CLEAR( tmp3 );
8884  free( arg3 );
8885  }
8886  {
8887  Py_CLEAR( tmp7 );
8888  }
8889  return resultobj;
8890 fail:
8891  {
8892  Py_CLEAR( tmp1 );
8893  }
8894  {
8895  Py_CLEAR( tmp2 );
8896  }
8897  {
8898  Py_CLEAR( tmp3 );
8899  free( arg3 );
8900  }
8901  {
8902  Py_CLEAR( tmp7 );
8903  }
8904  return NULL;
8905 }
8906 
8907 
8908 SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8909  PyObject *resultobj = 0;
8910  PLFLT *arg1 = (PLFLT *) 0 ;
8911  PLFLT *arg2 = (PLFLT *) 0 ;
8912  PLFLT **arg3 = (PLFLT **) 0 ;
8913  PLINT arg4 ;
8914  PLINT arg5 ;
8915  PLINT arg6 ;
8916  PLFLT *arg7 = (PLFLT *) 0 ;
8917  PLINT arg8 ;
8918  PLINT arg9 ;
8919  PLINT arg10 ;
8920  PLINT *arg11 = (PLINT *) 0 ;
8921  PLINT *arg12 = (PLINT *) 0 ;
8922  PyArrayObject *tmp1 = NULL ;
8923  PyArrayObject *tmp2 = NULL ;
8924  PyArrayObject *tmp3 = NULL ;
8925  int val6 ;
8926  int ecode6 = 0 ;
8927  PyArrayObject *tmp7 = NULL ;
8928  int val9 ;
8929  int ecode9 = 0 ;
8930  PyArrayObject *tmp10 = NULL ;
8931  PyArrayObject *tmp12 = NULL ;
8932  PyObject *swig_obj[8] ;
8933 
8934  if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
8935  {
8936  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8937  if ( tmp1 == NULL )
8938  return NULL;
8939  Xlen = PyArray_DIMS( tmp1 )[0];
8940  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8941  }
8942  {
8943  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8944  if ( tmp2 == NULL )
8945  return NULL;
8946  Ylen = PyArray_DIMS( tmp2 )[0];
8947  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8948  }
8949  {
8950  int i, size;
8951  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8952  if ( tmp3 == NULL )
8953  return NULL;
8954  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8955  {
8956  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8957  return NULL;
8958  }
8959  arg4 = PyArray_DIMS( tmp3 )[0];
8960  arg5 = PyArray_DIMS( tmp3 )[1];
8961  size = arg5;
8962  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8963  for ( i = 0; i < arg4; i++ )
8964  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8965  }
8966  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8967  if (!SWIG_IsOK(ecode6)) {
8968  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
8969  }
8970  arg6 = (PLINT)(val6);
8971  {
8972  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8973  if ( tmp7 == NULL )
8974  return NULL;
8975  arg8 = PyArray_DIMS( tmp7 )[0];
8976  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8977  }
8978  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
8979  if (!SWIG_IsOK(ecode9)) {
8980  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
8981  }
8982  arg9 = (PLINT)(val9);
8983  {
8984  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
8985  if ( tmp10 == NULL )
8986  return NULL;
8987  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
8988  arg11 = (PLINT *) PyArray_DATA( tmp10 );
8989  }
8990  {
8991  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
8992  if ( tmp12 == NULL )
8993  return NULL;
8994  if ( PyArray_DIMS( tmp12 )[0] != Alen )
8995  {
8996  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8997  return NULL;
8998  }
8999  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9000  }
9001  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);
9002  resultobj = SWIG_Py_Void();
9003  {
9004  Py_CLEAR( tmp1 );
9005  }
9006  {
9007  Py_CLEAR( tmp2 );
9008  }
9009  {
9010  Py_CLEAR( tmp3 );
9011  free( arg3 );
9012  }
9013  {
9014  Py_CLEAR( tmp7 );
9015  }
9016  {
9017  Py_CLEAR( tmp10 );
9018  }
9019  {
9020  Py_CLEAR( tmp12 );
9021  }
9022  return resultobj;
9023 fail:
9024  {
9025  Py_CLEAR( tmp1 );
9026  }
9027  {
9028  Py_CLEAR( tmp2 );
9029  }
9030  {
9031  Py_CLEAR( tmp3 );
9032  free( arg3 );
9033  }
9034  {
9035  Py_CLEAR( tmp7 );
9036  }
9037  {
9038  Py_CLEAR( tmp10 );
9039  }
9040  {
9041  Py_CLEAR( tmp12 );
9042  }
9043  return NULL;
9044 }
9045 
9046 
9047 SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048  PyObject *resultobj = 0;
9049  PLFLT *arg1 = (PLFLT *) 0 ;
9050  PLFLT *arg2 = (PLFLT *) 0 ;
9051  PLFLT **arg3 = (PLFLT **) 0 ;
9052  PLINT arg4 ;
9053  PLINT arg5 ;
9054  PLINT arg6 ;
9055  PLFLT *arg7 = (PLFLT *) 0 ;
9056  PLINT arg8 ;
9057  PyArrayObject *tmp1 = NULL ;
9058  PyArrayObject *tmp2 = NULL ;
9059  PyArrayObject *tmp3 = NULL ;
9060  int val6 ;
9061  int ecode6 = 0 ;
9062  PyArrayObject *tmp7 = NULL ;
9063  PyObject *swig_obj[5] ;
9064 
9065  if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9066  {
9067  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9068  if ( tmp1 == NULL )
9069  return NULL;
9070  Xlen = PyArray_DIMS( tmp1 )[0];
9071  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9072  }
9073  {
9074  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9075  if ( tmp2 == NULL )
9076  return NULL;
9077  Ylen = PyArray_DIMS( tmp2 )[0];
9078  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9079  }
9080  {
9081  int i, size;
9082  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9083  if ( tmp3 == NULL )
9084  return NULL;
9085  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9086  {
9087  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9088  return NULL;
9089  }
9090  arg4 = PyArray_DIMS( tmp3 )[0];
9091  arg5 = PyArray_DIMS( tmp3 )[1];
9092  size = arg5;
9093  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9094  for ( i = 0; i < arg4; i++ )
9095  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9096  }
9097  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9098  if (!SWIG_IsOK(ecode6)) {
9099  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9100  }
9101  arg6 = (PLINT)(val6);
9102  {
9103  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9104  if ( tmp7 == NULL )
9105  return NULL;
9106  arg8 = PyArray_DIMS( tmp7 )[0];
9107  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9108  }
9109  plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9110  resultobj = SWIG_Py_Void();
9111  {
9112  Py_CLEAR( tmp1 );
9113  }
9114  {
9115  Py_CLEAR( tmp2 );
9116  }
9117  {
9118  Py_CLEAR( tmp3 );
9119  free( arg3 );
9120  }
9121  {
9122  Py_CLEAR( tmp7 );
9123  }
9124  return resultobj;
9125 fail:
9126  {
9127  Py_CLEAR( tmp1 );
9128  }
9129  {
9130  Py_CLEAR( tmp2 );
9131  }
9132  {
9133  Py_CLEAR( tmp3 );
9134  free( arg3 );
9135  }
9136  {
9137  Py_CLEAR( tmp7 );
9138  }
9139  return NULL;
9140 }
9141 
9142 
9143 SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9144  PyObject *resultobj = 0;
9145  PLFLT *arg1 = (PLFLT *) 0 ;
9146  PLFLT *arg2 = (PLFLT *) 0 ;
9147  PLFLT **arg3 = (PLFLT **) 0 ;
9148  PLINT arg4 ;
9149  PLINT arg5 ;
9150  PLINT arg6 ;
9151  PLFLT *arg7 = (PLFLT *) 0 ;
9152  PLINT arg8 ;
9153  PLINT arg9 ;
9154  PLINT arg10 ;
9155  PLINT *arg11 = (PLINT *) 0 ;
9156  PLINT *arg12 = (PLINT *) 0 ;
9157  PyArrayObject *tmp1 = NULL ;
9158  PyArrayObject *tmp2 = NULL ;
9159  PyArrayObject *tmp3 = NULL ;
9160  int val6 ;
9161  int ecode6 = 0 ;
9162  PyArrayObject *tmp7 = NULL ;
9163  int val9 ;
9164  int ecode9 = 0 ;
9165  PyArrayObject *tmp10 = NULL ;
9166  PyArrayObject *tmp12 = NULL ;
9167  PyObject *swig_obj[8] ;
9168 
9169  if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9170  {
9171  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9172  if ( tmp1 == NULL )
9173  return NULL;
9174  Xlen = PyArray_DIMS( tmp1 )[0];
9175  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9176  }
9177  {
9178  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9179  if ( tmp2 == NULL )
9180  return NULL;
9181  Ylen = PyArray_DIMS( tmp2 )[0];
9182  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9183  }
9184  {
9185  int i, size;
9186  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9187  if ( tmp3 == NULL )
9188  return NULL;
9189  if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9190  {
9191  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9192  return NULL;
9193  }
9194  arg4 = PyArray_DIMS( tmp3 )[0];
9195  arg5 = PyArray_DIMS( tmp3 )[1];
9196  size = arg5;
9197  arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9198  for ( i = 0; i < arg4; i++ )
9199  arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9200  }
9201  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9202  if (!SWIG_IsOK(ecode6)) {
9203  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9204  }
9205  arg6 = (PLINT)(val6);
9206  {
9207  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9208  if ( tmp7 == NULL )
9209  return NULL;
9210  arg8 = PyArray_DIMS( tmp7 )[0];
9211  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9212  }
9213  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9214  if (!SWIG_IsOK(ecode9)) {
9215  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9216  }
9217  arg9 = (PLINT)(val9);
9218  {
9219  tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9220  if ( tmp10 == NULL )
9221  return NULL;
9222  arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9223  arg11 = (PLINT *) PyArray_DATA( tmp10 );
9224  }
9225  {
9226  tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9227  if ( tmp12 == NULL )
9228  return NULL;
9229  if ( PyArray_DIMS( tmp12 )[0] != Alen )
9230  {
9231  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9232  return NULL;
9233  }
9234  arg12 = (PLINT *) PyArray_DATA( tmp12 );
9235  }
9236  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);
9237  resultobj = SWIG_Py_Void();
9238  {
9239  Py_CLEAR( tmp1 );
9240  }
9241  {
9242  Py_CLEAR( tmp2 );
9243  }
9244  {
9245  Py_CLEAR( tmp3 );
9246  free( arg3 );
9247  }
9248  {
9249  Py_CLEAR( tmp7 );
9250  }
9251  {
9252  Py_CLEAR( tmp10 );
9253  }
9254  {
9255  Py_CLEAR( tmp12 );
9256  }
9257  return resultobj;
9258 fail:
9259  {
9260  Py_CLEAR( tmp1 );
9261  }
9262  {
9263  Py_CLEAR( tmp2 );
9264  }
9265  {
9266  Py_CLEAR( tmp3 );
9267  free( arg3 );
9268  }
9269  {
9270  Py_CLEAR( tmp7 );
9271  }
9272  {
9273  Py_CLEAR( tmp10 );
9274  }
9275  {
9276  Py_CLEAR( tmp12 );
9277  }
9278  return NULL;
9279 }
9280 
9281 
9282 SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283  PyObject *resultobj = 0;
9284  int *arg1 = (int *) 0 ;
9285  char **arg2 = (char **) 0 ;
9286  PLINT arg3 ;
9287  int tmp1 ;
9288  int val3 ;
9289  int ecode3 = 0 ;
9290  PyObject *swig_obj[2] ;
9291  PLINT result;
9292 
9293  if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9294  {
9295  int i;
9296  PyObject *unicode_string;
9297 
9298  if ( !PyList_Check( swig_obj[0] ) )
9299  {
9300  PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9301  return NULL;
9302  }
9303  tmp1 = PyList_Size( swig_obj[0] );
9304  arg1 = &tmp1;
9305  arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9306  for ( i = 0; i < tmp1; i++ )
9307  {
9308  PyObject *s = PyList_GetItem( swig_obj[0], i );
9309  if ( PyString_Check( s ) )
9310  {
9311  arg2[i] = PyString_AsString( s );
9312  }
9313  else if ( PyUnicode_Check( s ) )
9314  {
9315  // unicode_string is never freed? memory leak here?
9316  unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9317  arg2[i] = PyBytes_AS_STRING( unicode_string );
9318  }
9319  else
9320  {
9321  free( arg2 );
9322  PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9323  return NULL;
9324  }
9325  }
9326  arg2[i] = 0;
9327  }
9328  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9329  if (!SWIG_IsOK(ecode3)) {
9330  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9331  }
9332  arg3 = (PLINT)(val3);
9333  result = (PLINT)plparseopts(arg1,arg2,arg3);
9334  resultobj = SWIG_From_int((int)(result));
9335  {
9336  if ( arg2 )
9337  free( arg2 );
9338  }
9339  return resultobj;
9340 fail:
9341  {
9342  if ( arg2 )
9343  free( arg2 );
9344  }
9345  return NULL;
9346 }
9347 
9348 
9349 SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9350  PyObject *resultobj = 0;
9351  PLINT arg1 ;
9352  PLINT *arg2 = (PLINT *) 0 ;
9353  PLINT *arg3 = (PLINT *) 0 ;
9354  PyArrayObject *tmp1 = NULL ;
9355  PyArrayObject *tmp3 = NULL ;
9356  PyObject *swig_obj[2] ;
9357 
9358  if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9359  {
9360  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9361  if ( tmp1 == NULL )
9362  return NULL;
9363  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9364  arg2 = (PLINT *) PyArray_DATA( tmp1 );
9365  }
9366  {
9367  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9368  if ( tmp3 == NULL )
9369  return NULL;
9370  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9371  {
9372  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9373  return NULL;
9374  }
9375  arg3 = (PLINT *) PyArray_DATA( tmp3 );
9376  }
9377  plpat(arg1,(int const *)arg2,(int const *)arg3);
9378  resultobj = SWIG_Py_Void();
9379  {
9380  Py_CLEAR( tmp1 );
9381  }
9382  {
9383  Py_CLEAR( tmp3 );
9384  }
9385  return resultobj;
9386 fail:
9387  {
9388  Py_CLEAR( tmp1 );
9389  }
9390  {
9391  Py_CLEAR( tmp3 );
9392  }
9393  return NULL;
9394 }
9395 
9396 
9397 SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9398  PyObject *resultobj = 0;
9399  PLINT arg1 ;
9400  PLFLT arg2 ;
9401  PLFLT arg3 ;
9402  PLFLT arg4 ;
9403  PLFLT arg5 ;
9404  int val1 ;
9405  int ecode1 = 0 ;
9406  double val2 ;
9407  int ecode2 = 0 ;
9408  double val3 ;
9409  int ecode3 = 0 ;
9410  double val4 ;
9411  int ecode4 = 0 ;
9412  double val5 ;
9413  int ecode5 = 0 ;
9414  PyObject *swig_obj[5] ;
9415 
9416  if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
9417  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9418  if (!SWIG_IsOK(ecode1)) {
9419  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9420  }
9421  arg1 = (PLINT)(val1);
9422  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9423  if (!SWIG_IsOK(ecode2)) {
9424  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9425  }
9426  arg2 = (PLFLT)(val2);
9427  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9428  if (!SWIG_IsOK(ecode3)) {
9429  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9430  }
9431  arg3 = (PLFLT)(val3);
9432  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9433  if (!SWIG_IsOK(ecode4)) {
9434  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9435  }
9436  arg4 = (PLFLT)(val4);
9437  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9438  if (!SWIG_IsOK(ecode5)) {
9439  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9440  }
9441  arg5 = (PLFLT)(val5);
9442  plpath(arg1,arg2,arg3,arg4,arg5);
9443  resultobj = SWIG_Py_Void();
9444  return resultobj;
9445 fail:
9446  return NULL;
9447 }
9448 
9449 
9450 SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9451  PyObject *resultobj = 0;
9452  PLINT arg1 ;
9453  PLFLT *arg2 = (PLFLT *) 0 ;
9454  PLFLT *arg3 = (PLFLT *) 0 ;
9455  PLINT arg4 ;
9456  PyArrayObject *tmp1 = NULL ;
9457  PyArrayObject *tmp3 = NULL ;
9458  int val4 ;
9459  int ecode4 = 0 ;
9460  PyObject *swig_obj[3] ;
9461 
9462  if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
9463  {
9464  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9465  if ( tmp1 == NULL )
9466  return NULL;
9467  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9468  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9469  }
9470  {
9471  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9472  if ( tmp3 == NULL )
9473  return NULL;
9474  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9475  {
9476  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9477  return NULL;
9478  }
9479  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9480  }
9481  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
9482  if (!SWIG_IsOK(ecode4)) {
9483  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9484  }
9485  arg4 = (PLINT)(val4);
9486  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9487  resultobj = SWIG_Py_Void();
9488  {
9489  Py_CLEAR( tmp1 );
9490  }
9491  {
9492  Py_CLEAR( tmp3 );
9493  }
9494  return resultobj;
9495 fail:
9496  {
9497  Py_CLEAR( tmp1 );
9498  }
9499  {
9500  Py_CLEAR( tmp3 );
9501  }
9502  return NULL;
9503 }
9504 
9505 
9506 SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9507  PyObject *resultobj = 0;
9508  PLINT arg1 ;
9509  PLFLT *arg2 = (PLFLT *) 0 ;
9510  PLFLT *arg3 = (PLFLT *) 0 ;
9511  PLFLT *arg4 = (PLFLT *) 0 ;
9512  PLINT arg5 ;
9513  PyArrayObject *tmp1 = NULL ;
9514  PyArrayObject *tmp3 = NULL ;
9515  PyArrayObject *tmp4 = NULL ;
9516  int val5 ;
9517  int ecode5 = 0 ;
9518  PyObject *swig_obj[4] ;
9519 
9520  if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
9521  {
9522  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9523  if ( tmp1 == NULL )
9524  return NULL;
9525  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9526  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9527  }
9528  {
9529  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9530  if ( tmp3 == NULL )
9531  return NULL;
9532  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9533  {
9534  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9535  return NULL;
9536  }
9537  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9538  }
9539  {
9540  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9541  if ( tmp4 == NULL )
9542  return NULL;
9543  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9544  {
9545  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9546  return NULL;
9547  }
9548  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9549  }
9550  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
9551  if (!SWIG_IsOK(ecode5)) {
9552  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9553  }
9554  arg5 = (PLINT)(val5);
9555  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9556  resultobj = SWIG_Py_Void();
9557  {
9558  Py_CLEAR( tmp1 );
9559  }
9560  {
9561  Py_CLEAR( tmp3 );
9562  }
9563  {
9564  Py_CLEAR( tmp4 );
9565  }
9566  return resultobj;
9567 fail:
9568  {
9569  Py_CLEAR( tmp1 );
9570  }
9571  {
9572  Py_CLEAR( tmp3 );
9573  }
9574  {
9575  Py_CLEAR( tmp4 );
9576  }
9577  return NULL;
9578 }
9579 
9580 
9581 SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9582  PyObject *resultobj = 0;
9583  PLINT arg1 ;
9584  PLFLT *arg2 = (PLFLT *) 0 ;
9585  PLFLT *arg3 = (PLFLT *) 0 ;
9586  PLFLT *arg4 = (PLFLT *) 0 ;
9587  PLBOOL *arg5 = (PLBOOL *) 0 ;
9588  PLBOOL arg6 ;
9589  PyArrayObject *tmp1 = NULL ;
9590  PyArrayObject *tmp3 = NULL ;
9591  PyArrayObject *tmp4 = NULL ;
9592  PyArrayObject *tmp5 = NULL ;
9593  int val6 ;
9594  int ecode6 = 0 ;
9595  PyObject *swig_obj[5] ;
9596 
9597  if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
9598  {
9599  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9600  if ( tmp1 == NULL )
9601  return NULL;
9602  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9603  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9604  }
9605  {
9606  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9607  if ( tmp3 == NULL )
9608  return NULL;
9609  if ( PyArray_DIMS( tmp3 )[0] != Alen )
9610  {
9611  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9612  return NULL;
9613  }
9614  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9615  }
9616  {
9617  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9618  if ( tmp4 == NULL )
9619  return NULL;
9620  if ( PyArray_DIMS( tmp4 )[0] != Alen )
9621  {
9622  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9623  return NULL;
9624  }
9625  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9626  }
9627  {
9628  tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
9629  if ( tmp5 == NULL )
9630  return NULL;
9631  if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9632  {
9633  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9634  return NULL;
9635  }
9636  arg5 = (PLINT *) PyArray_DATA( tmp5 );
9637  }
9638  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
9639  if (!SWIG_IsOK(ecode6)) {
9640  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9641  }
9642  arg6 = (PLBOOL)(val6);
9643  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9644  resultobj = SWIG_Py_Void();
9645  {
9646  Py_CLEAR( tmp1 );
9647  }
9648  {
9649  Py_CLEAR( tmp3 );
9650  }
9651  {
9652  Py_CLEAR( tmp4 );
9653  }
9654  {
9655  Py_CLEAR( tmp5 );
9656  }
9657  return resultobj;
9658 fail:
9659  {
9660  Py_CLEAR( tmp1 );
9661  }
9662  {
9663  Py_CLEAR( tmp3 );
9664  }
9665  {
9666  Py_CLEAR( tmp4 );
9667  }
9668  {
9669  Py_CLEAR( tmp5 );
9670  }
9671  return NULL;
9672 }
9673 
9674 
9675 SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9676  PyObject *resultobj = 0;
9677  PLINT arg1 ;
9678  PLINT arg2 ;
9679  int val1 ;
9680  int ecode1 = 0 ;
9681  int val2 ;
9682  int ecode2 = 0 ;
9683  PyObject *swig_obj[2] ;
9684 
9685  if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
9686  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9687  if (!SWIG_IsOK(ecode1)) {
9688  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9689  }
9690  arg1 = (PLINT)(val1);
9691  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
9692  if (!SWIG_IsOK(ecode2)) {
9693  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
9694  }
9695  arg2 = (PLINT)(val2);
9696  plprec(arg1,arg2);
9697  resultobj = SWIG_Py_Void();
9698  return resultobj;
9699 fail:
9700  return NULL;
9701 }
9702 
9703 
9704 SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9705  PyObject *resultobj = 0;
9706  PLINT arg1 ;
9707  int val1 ;
9708  int ecode1 = 0 ;
9709  PyObject *swig_obj[1] ;
9710 
9711  if (!args) SWIG_fail;
9712  swig_obj[0] = args;
9713  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9714  if (!SWIG_IsOK(ecode1)) {
9715  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
9716  }
9717  arg1 = (PLINT)(val1);
9718  plpsty(arg1);
9719  resultobj = SWIG_Py_Void();
9720  return resultobj;
9721 fail:
9722  return NULL;
9723 }
9724 
9725 
9726 SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727  PyObject *resultobj = 0;
9728  PLFLT arg1 ;
9729  PLFLT arg2 ;
9730  PLFLT arg3 ;
9731  PLFLT arg4 ;
9732  PLFLT arg5 ;
9733  char *arg6 = (char *) 0 ;
9734  double val1 ;
9735  int ecode1 = 0 ;
9736  double val2 ;
9737  int ecode2 = 0 ;
9738  double val3 ;
9739  int ecode3 = 0 ;
9740  double val4 ;
9741  int ecode4 = 0 ;
9742  double val5 ;
9743  int ecode5 = 0 ;
9744  int res6 ;
9745  char *buf6 = 0 ;
9746  int alloc6 = 0 ;
9747  PyObject *swig_obj[6] ;
9748 
9749  if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
9750  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9751  if (!SWIG_IsOK(ecode1)) {
9752  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
9753  }
9754  arg1 = (PLFLT)(val1);
9755  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9756  if (!SWIG_IsOK(ecode2)) {
9757  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
9758  }
9759  arg2 = (PLFLT)(val2);
9760  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9761  if (!SWIG_IsOK(ecode3)) {
9762  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
9763  }
9764  arg3 = (PLFLT)(val3);
9765  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9766  if (!SWIG_IsOK(ecode4)) {
9767  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
9768  }
9769  arg4 = (PLFLT)(val4);
9770  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9771  if (!SWIG_IsOK(ecode5)) {
9772  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
9773  }
9774  arg5 = (PLFLT)(val5);
9775  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
9776  if (!SWIG_IsOK(res6)) {
9777  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
9778  }
9779  arg6 = (char *)(buf6);
9780  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
9781  resultobj = SWIG_Py_Void();
9782  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9783  return resultobj;
9784 fail:
9785  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9786  return NULL;
9787 }
9788 
9789 
9790 SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9791  PyObject *resultobj = 0;
9792  PLFLT arg1 ;
9793  PLFLT arg2 ;
9794  PLFLT arg3 ;
9795  PLFLT arg4 ;
9796  PLFLT arg5 ;
9797  PLFLT arg6 ;
9798  PLFLT arg7 ;
9799  PLFLT arg8 ;
9800  PLFLT arg9 ;
9801  PLFLT arg10 ;
9802  char *arg11 = (char *) 0 ;
9803  double val1 ;
9804  int ecode1 = 0 ;
9805  double val2 ;
9806  int ecode2 = 0 ;
9807  double val3 ;
9808  int ecode3 = 0 ;
9809  double val4 ;
9810  int ecode4 = 0 ;
9811  double val5 ;
9812  int ecode5 = 0 ;
9813  double val6 ;
9814  int ecode6 = 0 ;
9815  double val7 ;
9816  int ecode7 = 0 ;
9817  double val8 ;
9818  int ecode8 = 0 ;
9819  double val9 ;
9820  int ecode9 = 0 ;
9821  double val10 ;
9822  int ecode10 = 0 ;
9823  int res11 ;
9824  char *buf11 = 0 ;
9825  int alloc11 = 0 ;
9826  PyObject *swig_obj[11] ;
9827 
9828  if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
9829  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9830  if (!SWIG_IsOK(ecode1)) {
9831  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
9832  }
9833  arg1 = (PLFLT)(val1);
9834  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9835  if (!SWIG_IsOK(ecode2)) {
9836  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
9837  }
9838  arg2 = (PLFLT)(val2);
9839  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9840  if (!SWIG_IsOK(ecode3)) {
9841  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
9842  }
9843  arg3 = (PLFLT)(val3);
9844  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9845  if (!SWIG_IsOK(ecode4)) {
9846  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
9847  }
9848  arg4 = (PLFLT)(val4);
9849  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9850  if (!SWIG_IsOK(ecode5)) {
9851  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
9852  }
9853  arg5 = (PLFLT)(val5);
9854  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
9855  if (!SWIG_IsOK(ecode6)) {
9856  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
9857  }
9858  arg6 = (PLFLT)(val6);
9859  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
9860  if (!SWIG_IsOK(ecode7)) {
9861  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
9862  }
9863  arg7 = (PLFLT)(val7);
9864  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
9865  if (!SWIG_IsOK(ecode8)) {
9866  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
9867  }
9868  arg8 = (PLFLT)(val8);
9869  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
9870  if (!SWIG_IsOK(ecode9)) {
9871  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
9872  }
9873  arg9 = (PLFLT)(val9);
9874  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
9875  if (!SWIG_IsOK(ecode10)) {
9876  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
9877  }
9878  arg10 = (PLFLT)(val10);
9879  res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
9880  if (!SWIG_IsOK(res11)) {
9881  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
9882  }
9883  arg11 = (char *)(buf11);
9884  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
9885  resultobj = SWIG_Py_Void();
9886  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9887  return resultobj;
9888 fail:
9889  if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9890  return NULL;
9891 }
9892 
9893 
9894 SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895  PyObject *resultobj = 0;
9896  PLFLT result;
9897 
9898  if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
9899  result = (PLFLT)plrandd();
9900  resultobj = SWIG_From_double((double)(result));
9901  return resultobj;
9902 fail:
9903  return NULL;
9904 }
9905 
9906 
9907 SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9908  PyObject *resultobj = 0;
9909 
9910  if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
9911  plreplot();
9912  resultobj = SWIG_Py_Void();
9913  return resultobj;
9914 fail:
9915  return NULL;
9916 }
9917 
9918 
9919 SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9920  PyObject *resultobj = 0;
9921  PLFLT arg1 ;
9922  PLFLT arg2 ;
9923  PLFLT arg3 ;
9924  PLFLT *arg4 = (PLFLT *) 0 ;
9925  PLFLT *arg5 = (PLFLT *) 0 ;
9926  PLFLT *arg6 = (PLFLT *) 0 ;
9927  double val1 ;
9928  int ecode1 = 0 ;
9929  double val2 ;
9930  int ecode2 = 0 ;
9931  double val3 ;
9932  int ecode3 = 0 ;
9933  PLFLT temp4 ;
9934  int res4 = SWIG_TMPOBJ ;
9935  PLFLT temp5 ;
9936  int res5 = SWIG_TMPOBJ ;
9937  PLFLT temp6 ;
9938  int res6 = SWIG_TMPOBJ ;
9939  PyObject *swig_obj[3] ;
9940 
9941  arg4 = &temp4;
9942  arg5 = &temp5;
9943  arg6 = &temp6;
9944  if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
9945  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9946  if (!SWIG_IsOK(ecode1)) {
9947  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
9948  }
9949  arg1 = (PLFLT)(val1);
9950  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9951  if (!SWIG_IsOK(ecode2)) {
9952  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
9953  }
9954  arg2 = (PLFLT)(val2);
9955  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9956  if (!SWIG_IsOK(ecode3)) {
9957  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
9958  }
9959  arg3 = (PLFLT)(val3);
9960  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
9961  resultobj = SWIG_Py_Void();
9962  if (SWIG_IsTmpObj(res4)) {
9963  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
9964  } else {
9965  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9966  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
9967  }
9968  if (SWIG_IsTmpObj(res5)) {
9969  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
9970  } else {
9971  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9972  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
9973  }
9974  if (SWIG_IsTmpObj(res6)) {
9975  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
9976  } else {
9977  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9978  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
9979  }
9980  return resultobj;
9981 fail:
9982  return NULL;
9983 }
9984 
9985 
9986 SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9987  PyObject *resultobj = 0;
9988  PLFLT arg1 ;
9989  PLFLT arg2 ;
9990  double val1 ;
9991  int ecode1 = 0 ;
9992  double val2 ;
9993  int ecode2 = 0 ;
9994  PyObject *swig_obj[2] ;
9995 
9996  if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
9997  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9998  if (!SWIG_IsOK(ecode1)) {
9999  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10000  }
10001  arg1 = (PLFLT)(val1);
10002  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10003  if (!SWIG_IsOK(ecode2)) {
10004  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10005  }
10006  arg2 = (PLFLT)(val2);
10007  plschr(arg1,arg2);
10008  resultobj = SWIG_Py_Void();
10009  return resultobj;
10010 fail:
10011  return NULL;
10012 }
10013 
10014 
10015 SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016  PyObject *resultobj = 0;
10017  PLINT *arg1 = (PLINT *) 0 ;
10018  PLINT *arg2 = (PLINT *) 0 ;
10019  PLINT *arg3 = (PLINT *) 0 ;
10020  PLINT arg4 ;
10021  PyArrayObject *tmp1 = NULL ;
10022  PyArrayObject *tmp2 = NULL ;
10023  PyArrayObject *tmp3 = NULL ;
10024  PyObject *swig_obj[3] ;
10025 
10026  if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10027  {
10028  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10029  if ( tmp1 == NULL )
10030  return NULL;
10031  Alen = PyArray_DIMS( tmp1 )[0];
10032  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10033  }
10034  {
10035  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10036  if ( tmp2 == NULL )
10037  return NULL;
10038  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10039  {
10040  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10041  return NULL;
10042  }
10043  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10044  }
10045  {
10046  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10047  if ( tmp3 == NULL )
10048  return NULL;
10049  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10050  {
10051  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10052  return NULL;
10053  }
10054  arg4 = PyArray_DIMS( tmp3 )[0];
10055  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10056  }
10057  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10058  resultobj = SWIG_Py_Void();
10059  {
10060  Py_CLEAR( tmp1 );
10061  }
10062  {
10063  Py_CLEAR( tmp2 );
10064  }
10065  {
10066  Py_CLEAR( tmp3 );
10067  }
10068  return resultobj;
10069 fail:
10070  {
10071  Py_CLEAR( tmp1 );
10072  }
10073  {
10074  Py_CLEAR( tmp2 );
10075  }
10076  {
10077  Py_CLEAR( tmp3 );
10078  }
10079  return NULL;
10080 }
10081 
10082 
10083 SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10084  PyObject *resultobj = 0;
10085  PLINT *arg1 = (PLINT *) 0 ;
10086  PLINT *arg2 = (PLINT *) 0 ;
10087  PLINT *arg3 = (PLINT *) 0 ;
10088  PLFLT *arg4 = (PLFLT *) 0 ;
10089  PLINT arg5 ;
10090  PyArrayObject *tmp1 = NULL ;
10091  PyArrayObject *tmp2 = NULL ;
10092  PyArrayObject *tmp3 = NULL ;
10093  PyArrayObject *tmp4 = NULL ;
10094  PyObject *swig_obj[4] ;
10095 
10096  if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10097  {
10098  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10099  if ( tmp1 == NULL )
10100  return NULL;
10101  Alen = PyArray_DIMS( tmp1 )[0];
10102  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10103  }
10104  {
10105  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10106  if ( tmp2 == NULL )
10107  return NULL;
10108  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10109  {
10110  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10111  return NULL;
10112  }
10113  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10114  }
10115  {
10116  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10117  if ( tmp3 == NULL )
10118  return NULL;
10119  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10120  {
10121  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10122  return NULL;
10123  }
10124  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10125  }
10126  {
10127  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10128  if ( tmp4 == NULL )
10129  return NULL;
10130  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10131  {
10132  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10133  return NULL;
10134  }
10135  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10136  arg5 = PyArray_DIMS( tmp4 )[0];
10137  }
10138  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10139  resultobj = SWIG_Py_Void();
10140  {
10141  Py_CLEAR( tmp1 );
10142  }
10143  {
10144  Py_CLEAR( tmp2 );
10145  }
10146  {
10147  Py_CLEAR( tmp3 );
10148  }
10149  {
10150  Py_CLEAR( tmp4 );
10151  }
10152  return resultobj;
10153 fail:
10154  {
10155  Py_CLEAR( tmp1 );
10156  }
10157  {
10158  Py_CLEAR( tmp2 );
10159  }
10160  {
10161  Py_CLEAR( tmp3 );
10162  }
10163  {
10164  Py_CLEAR( tmp4 );
10165  }
10166  return NULL;
10167 }
10168 
10169 
10170 SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10171  PyObject *resultobj = 0;
10172  PLINT arg1 ;
10173  int val1 ;
10174  int ecode1 = 0 ;
10175  PyObject *swig_obj[1] ;
10176 
10177  if (!args) SWIG_fail;
10178  swig_obj[0] = args;
10179  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10180  if (!SWIG_IsOK(ecode1)) {
10181  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10182  }
10183  arg1 = (PLINT)(val1);
10184  plscmap0n(arg1);
10185  resultobj = SWIG_Py_Void();
10186  return resultobj;
10187 fail:
10188  return NULL;
10189 }
10190 
10191 
10192 SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10193  PyObject *resultobj = 0;
10194  PLINT *arg1 = (PLINT *) 0 ;
10195  PLINT *arg2 = (PLINT *) 0 ;
10196  PLINT *arg3 = (PLINT *) 0 ;
10197  PLINT arg4 ;
10198  PyArrayObject *tmp1 = NULL ;
10199  PyArrayObject *tmp2 = NULL ;
10200  PyArrayObject *tmp3 = NULL ;
10201  PyObject *swig_obj[3] ;
10202 
10203  if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10204  {
10205  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10206  if ( tmp1 == NULL )
10207  return NULL;
10208  Alen = PyArray_DIMS( tmp1 )[0];
10209  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10210  }
10211  {
10212  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10213  if ( tmp2 == NULL )
10214  return NULL;
10215  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10216  {
10217  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10218  return NULL;
10219  }
10220  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10221  }
10222  {
10223  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10224  if ( tmp3 == NULL )
10225  return NULL;
10226  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10227  {
10228  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10229  return NULL;
10230  }
10231  arg4 = PyArray_DIMS( tmp3 )[0];
10232  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10233  }
10234  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10235  resultobj = SWIG_Py_Void();
10236  {
10237  Py_CLEAR( tmp1 );
10238  }
10239  {
10240  Py_CLEAR( tmp2 );
10241  }
10242  {
10243  Py_CLEAR( tmp3 );
10244  }
10245  return resultobj;
10246 fail:
10247  {
10248  Py_CLEAR( tmp1 );
10249  }
10250  {
10251  Py_CLEAR( tmp2 );
10252  }
10253  {
10254  Py_CLEAR( tmp3 );
10255  }
10256  return NULL;
10257 }
10258 
10259 
10260 SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10261  PyObject *resultobj = 0;
10262  PLINT *arg1 = (PLINT *) 0 ;
10263  PLINT *arg2 = (PLINT *) 0 ;
10264  PLINT *arg3 = (PLINT *) 0 ;
10265  PLFLT *arg4 = (PLFLT *) 0 ;
10266  PLINT arg5 ;
10267  PyArrayObject *tmp1 = NULL ;
10268  PyArrayObject *tmp2 = NULL ;
10269  PyArrayObject *tmp3 = NULL ;
10270  PyArrayObject *tmp4 = NULL ;
10271  PyObject *swig_obj[4] ;
10272 
10273  if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10274  {
10275  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10276  if ( tmp1 == NULL )
10277  return NULL;
10278  Alen = PyArray_DIMS( tmp1 )[0];
10279  arg1 = (PLINT *) PyArray_DATA( tmp1 );
10280  }
10281  {
10282  tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10283  if ( tmp2 == NULL )
10284  return NULL;
10285  if ( PyArray_DIMS( tmp2 )[0] != Alen )
10286  {
10287  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10288  return NULL;
10289  }
10290  arg2 = (PLINT *) PyArray_DATA( tmp2 );
10291  }
10292  {
10293  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10294  if ( tmp3 == NULL )
10295  return NULL;
10296  if ( PyArray_DIMS( tmp3 )[0] != Alen )
10297  {
10298  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10299  return NULL;
10300  }
10301  arg3 = (PLINT *) PyArray_DATA( tmp3 );
10302  }
10303  {
10304  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10305  if ( tmp4 == NULL )
10306  return NULL;
10307  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10308  {
10309  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10310  return NULL;
10311  }
10312  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10313  arg5 = PyArray_DIMS( tmp4 )[0];
10314  }
10315  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10316  resultobj = SWIG_Py_Void();
10317  {
10318  Py_CLEAR( tmp1 );
10319  }
10320  {
10321  Py_CLEAR( tmp2 );
10322  }
10323  {
10324  Py_CLEAR( tmp3 );
10325  }
10326  {
10327  Py_CLEAR( tmp4 );
10328  }
10329  return resultobj;
10330 fail:
10331  {
10332  Py_CLEAR( tmp1 );
10333  }
10334  {
10335  Py_CLEAR( tmp2 );
10336  }
10337  {
10338  Py_CLEAR( tmp3 );
10339  }
10340  {
10341  Py_CLEAR( tmp4 );
10342  }
10343  return NULL;
10344 }
10345 
10346 
10347 SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10348  PyObject *resultobj = 0;
10349  PLBOOL arg1 ;
10350  PLINT arg2 ;
10351  PLFLT *arg3 = (PLFLT *) 0 ;
10352  PLFLT *arg4 = (PLFLT *) 0 ;
10353  PLFLT *arg5 = (PLFLT *) 0 ;
10354  PLFLT *arg6 = (PLFLT *) 0 ;
10355  PLBOOL *arg7 = (PLBOOL *) 0 ;
10356  int val1 ;
10357  int ecode1 = 0 ;
10358  PyArrayObject *tmp2 = NULL ;
10359  PyArrayObject *tmp4 = NULL ;
10360  PyArrayObject *tmp5 = NULL ;
10361  PyArrayObject *tmp6 = NULL ;
10362  PyArrayObject *tmp7 = NULL ;
10363  PyObject *swig_obj[6] ;
10364 
10365  if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
10366  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10367  if (!SWIG_IsOK(ecode1)) {
10368  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10369  }
10370  arg1 = (PLBOOL)(val1);
10371  {
10372  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10373  if ( tmp2 == NULL )
10374  return NULL;
10375  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10376  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10377  }
10378  {
10379  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10380  if ( tmp4 == NULL )
10381  return NULL;
10382  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10383  {
10384  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10385  return NULL;
10386  }
10387  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10388  }
10389  {
10390  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10391  if ( tmp5 == NULL )
10392  return NULL;
10393  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10394  {
10395  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10396  return NULL;
10397  }
10398  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10399  }
10400  {
10401  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10402  if ( tmp6 == NULL )
10403  return NULL;
10404  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10405  {
10406  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10407  return NULL;
10408  }
10409  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10410  }
10411  {
10412  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
10413  if ( tmp7 == NULL )
10414  return NULL;
10415  if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10416  {
10417  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10418  return NULL;
10419  }
10420  arg7 = (PLINT *) PyArray_DATA( tmp7 );
10421  }
10422  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10423  resultobj = SWIG_Py_Void();
10424  {
10425  Py_CLEAR( tmp2 );
10426  }
10427  {
10428  Py_CLEAR( tmp4 );
10429  }
10430  {
10431  Py_CLEAR( tmp5 );
10432  }
10433  {
10434  Py_CLEAR( tmp6 );
10435  }
10436  {
10437  Py_CLEAR( tmp7 );
10438  }
10439  return resultobj;
10440 fail:
10441  {
10442  Py_CLEAR( tmp2 );
10443  }
10444  {
10445  Py_CLEAR( tmp4 );
10446  }
10447  {
10448  Py_CLEAR( tmp5 );
10449  }
10450  {
10451  Py_CLEAR( tmp6 );
10452  }
10453  {
10454  Py_CLEAR( tmp7 );
10455  }
10456  return NULL;
10457 }
10458 
10459 
10460 SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10461  PyObject *resultobj = 0;
10462  PLBOOL arg1 ;
10463  PLINT arg2 ;
10464  PLFLT *arg3 = (PLFLT *) 0 ;
10465  PLFLT *arg4 = (PLFLT *) 0 ;
10466  PLFLT *arg5 = (PLFLT *) 0 ;
10467  PLFLT *arg6 = (PLFLT *) 0 ;
10468  PLFLT *arg7 = (PLFLT *) 0 ;
10469  PLBOOL *arg8 = (PLBOOL *) 0 ;
10470  int val1 ;
10471  int ecode1 = 0 ;
10472  PyArrayObject *tmp2 = NULL ;
10473  PyArrayObject *tmp4 = NULL ;
10474  PyArrayObject *tmp5 = NULL ;
10475  PyArrayObject *tmp6 = NULL ;
10476  PyArrayObject *tmp7 = NULL ;
10477  PyArrayObject *tmp8 = NULL ;
10478  PyObject *swig_obj[7] ;
10479 
10480  if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
10481  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10482  if (!SWIG_IsOK(ecode1)) {
10483  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10484  }
10485  arg1 = (PLBOOL)(val1);
10486  {
10487  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10488  if ( tmp2 == NULL )
10489  return NULL;
10490  arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10491  arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10492  }
10493  {
10494  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10495  if ( tmp4 == NULL )
10496  return NULL;
10497  if ( PyArray_DIMS( tmp4 )[0] != Alen )
10498  {
10499  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10500  return NULL;
10501  }
10502  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10503  }
10504  {
10505  tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10506  if ( tmp5 == NULL )
10507  return NULL;
10508  if ( PyArray_DIMS( tmp5 )[0] != Alen )
10509  {
10510  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10511  return NULL;
10512  }
10513  arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10514  }
10515  {
10516  tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10517  if ( tmp6 == NULL )
10518  return NULL;
10519  if ( PyArray_DIMS( tmp6 )[0] != Alen )
10520  {
10521  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10522  return NULL;
10523  }
10524  arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10525  }
10526  {
10527  tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
10528  if ( tmp7 == NULL )
10529  return NULL;
10530  if ( PyArray_DIMS( tmp7 )[0] != Alen )
10531  {
10532  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10533  return NULL;
10534  }
10535  arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10536  }
10537  {
10538  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
10539  if ( tmp8 == NULL )
10540  return NULL;
10541  if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10542  {
10543  PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10544  return NULL;
10545  }
10546  arg8 = (PLINT *) PyArray_DATA( tmp8 );
10547  }
10548  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10549  resultobj = SWIG_Py_Void();
10550  {
10551  Py_CLEAR( tmp2 );
10552  }
10553  {
10554  Py_CLEAR( tmp4 );
10555  }
10556  {
10557  Py_CLEAR( tmp5 );
10558  }
10559  {
10560  Py_CLEAR( tmp6 );
10561  }
10562  {
10563  Py_CLEAR( tmp7 );
10564  }
10565  {
10566  Py_CLEAR( tmp8 );
10567  }
10568  return resultobj;
10569 fail:
10570  {
10571  Py_CLEAR( tmp2 );
10572  }
10573  {
10574  Py_CLEAR( tmp4 );
10575  }
10576  {
10577  Py_CLEAR( tmp5 );
10578  }
10579  {
10580  Py_CLEAR( tmp6 );
10581  }
10582  {
10583  Py_CLEAR( tmp7 );
10584  }
10585  {
10586  Py_CLEAR( tmp8 );
10587  }
10588  return NULL;
10589 }
10590 
10591 
10592 SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10593  PyObject *resultobj = 0;
10594  PLINT arg1 ;
10595  int val1 ;
10596  int ecode1 = 0 ;
10597  PyObject *swig_obj[1] ;
10598 
10599  if (!args) SWIG_fail;
10600  swig_obj[0] = args;
10601  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10602  if (!SWIG_IsOK(ecode1)) {
10603  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10604  }
10605  arg1 = (PLINT)(val1);
10606  plscmap1n(arg1);
10607  resultobj = SWIG_Py_Void();
10608  return resultobj;
10609 fail:
10610  return NULL;
10611 }
10612 
10613 
10614 SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10615  PyObject *resultobj = 0;
10616  PLFLT arg1 ;
10617  PLFLT arg2 ;
10618  double val1 ;
10619  int ecode1 = 0 ;
10620  double val2 ;
10621  int ecode2 = 0 ;
10622  PyObject *swig_obj[2] ;
10623 
10624  if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
10625  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10626  if (!SWIG_IsOK(ecode1)) {
10627  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10628  }
10629  arg1 = (PLFLT)(val1);
10630  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10631  if (!SWIG_IsOK(ecode2)) {
10632  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10633  }
10634  arg2 = (PLFLT)(val2);
10635  plscmap1_range(arg1,arg2);
10636  resultobj = SWIG_Py_Void();
10637  return resultobj;
10638 fail:
10639  return NULL;
10640 }
10641 
10642 
10643 SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10644  PyObject *resultobj = 0;
10645  PLFLT *arg1 = (PLFLT *) 0 ;
10646  PLFLT *arg2 = (PLFLT *) 0 ;
10647  PLFLT temp1 ;
10648  int res1 = SWIG_TMPOBJ ;
10649  PLFLT temp2 ;
10650  int res2 = SWIG_TMPOBJ ;
10651 
10652  arg1 = &temp1;
10653  arg2 = &temp2;
10654  if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
10655  plgcmap1_range(arg1,arg2);
10656  resultobj = SWIG_Py_Void();
10657  if (SWIG_IsTmpObj(res1)) {
10658  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
10659  } else {
10660  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10661  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10662  }
10663  if (SWIG_IsTmpObj(res2)) {
10664  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
10665  } else {
10666  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10667  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10668  }
10669  return resultobj;
10670 fail:
10671  return NULL;
10672 }
10673 
10674 
10675 SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10676  PyObject *resultobj = 0;
10677  PLINT arg1 ;
10678  PLINT arg2 ;
10679  PLINT arg3 ;
10680  PLINT arg4 ;
10681  int val1 ;
10682  int ecode1 = 0 ;
10683  int val2 ;
10684  int ecode2 = 0 ;
10685  int val3 ;
10686  int ecode3 = 0 ;
10687  int val4 ;
10688  int ecode4 = 0 ;
10689  PyObject *swig_obj[4] ;
10690 
10691  if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
10692  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10693  if (!SWIG_IsOK(ecode1)) {
10694  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10695  }
10696  arg1 = (PLINT)(val1);
10697  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10698  if (!SWIG_IsOK(ecode2)) {
10699  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10700  }
10701  arg2 = (PLINT)(val2);
10702  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10703  if (!SWIG_IsOK(ecode3)) {
10704  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10705  }
10706  arg3 = (PLINT)(val3);
10707  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10708  if (!SWIG_IsOK(ecode4)) {
10709  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10710  }
10711  arg4 = (PLINT)(val4);
10712  plscol0(arg1,arg2,arg3,arg4);
10713  resultobj = SWIG_Py_Void();
10714  return resultobj;
10715 fail:
10716  return NULL;
10717 }
10718 
10719 
10720 SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10721  PyObject *resultobj = 0;
10722  PLINT arg1 ;
10723  PLINT arg2 ;
10724  PLINT arg3 ;
10725  PLINT arg4 ;
10726  PLFLT arg5 ;
10727  int val1 ;
10728  int ecode1 = 0 ;
10729  int val2 ;
10730  int ecode2 = 0 ;
10731  int val3 ;
10732  int ecode3 = 0 ;
10733  int val4 ;
10734  int ecode4 = 0 ;
10735  double val5 ;
10736  int ecode5 = 0 ;
10737  PyObject *swig_obj[5] ;
10738 
10739  if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
10740  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10741  if (!SWIG_IsOK(ecode1)) {
10742  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10743  }
10744  arg1 = (PLINT)(val1);
10745  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10746  if (!SWIG_IsOK(ecode2)) {
10747  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10748  }
10749  arg2 = (PLINT)(val2);
10750  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10751  if (!SWIG_IsOK(ecode3)) {
10752  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10753  }
10754  arg3 = (PLINT)(val3);
10755  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10756  if (!SWIG_IsOK(ecode4)) {
10757  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10758  }
10759  arg4 = (PLINT)(val4);
10760  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10761  if (!SWIG_IsOK(ecode5)) {
10762  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10763  }
10764  arg5 = (PLFLT)(val5);
10765  plscol0a(arg1,arg2,arg3,arg4,arg5);
10766  resultobj = SWIG_Py_Void();
10767  return resultobj;
10768 fail:
10769  return NULL;
10770 }
10771 
10772 
10773 SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10774  PyObject *resultobj = 0;
10775  PLINT arg1 ;
10776  PLINT arg2 ;
10777  PLINT arg3 ;
10778  int val1 ;
10779  int ecode1 = 0 ;
10780  int val2 ;
10781  int ecode2 = 0 ;
10782  int val3 ;
10783  int ecode3 = 0 ;
10784  PyObject *swig_obj[3] ;
10785 
10786  if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
10787  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10788  if (!SWIG_IsOK(ecode1)) {
10789  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10790  }
10791  arg1 = (PLINT)(val1);
10792  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10793  if (!SWIG_IsOK(ecode2)) {
10794  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10795  }
10796  arg2 = (PLINT)(val2);
10797  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10798  if (!SWIG_IsOK(ecode3)) {
10799  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10800  }
10801  arg3 = (PLINT)(val3);
10802  plscolbg(arg1,arg2,arg3);
10803  resultobj = SWIG_Py_Void();
10804  return resultobj;
10805 fail:
10806  return NULL;
10807 }
10808 
10809 
10810 SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10811  PyObject *resultobj = 0;
10812  PLINT arg1 ;
10813  PLINT arg2 ;
10814  PLINT arg3 ;
10815  PLFLT arg4 ;
10816  int val1 ;
10817  int ecode1 = 0 ;
10818  int val2 ;
10819  int ecode2 = 0 ;
10820  int val3 ;
10821  int ecode3 = 0 ;
10822  double val4 ;
10823  int ecode4 = 0 ;
10824  PyObject *swig_obj[4] ;
10825 
10826  if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
10827  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10828  if (!SWIG_IsOK(ecode1)) {
10829  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10830  }
10831  arg1 = (PLINT)(val1);
10832  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10833  if (!SWIG_IsOK(ecode2)) {
10834  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10835  }
10836  arg2 = (PLINT)(val2);
10837  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10838  if (!SWIG_IsOK(ecode3)) {
10839  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10840  }
10841  arg3 = (PLINT)(val3);
10842  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10843  if (!SWIG_IsOK(ecode4)) {
10844  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10845  }
10846  arg4 = (PLFLT)(val4);
10847  plscolbga(arg1,arg2,arg3,arg4);
10848  resultobj = SWIG_Py_Void();
10849  return resultobj;
10850 fail:
10851  return NULL;
10852 }
10853 
10854 
10855 SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10856  PyObject *resultobj = 0;
10857  PLINT arg1 ;
10858  int val1 ;
10859  int ecode1 = 0 ;
10860  PyObject *swig_obj[1] ;
10861 
10862  if (!args) SWIG_fail;
10863  swig_obj[0] = args;
10864  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10865  if (!SWIG_IsOK(ecode1)) {
10866  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10867  }
10868  arg1 = (PLINT)(val1);
10869  plscolor(arg1);
10870  resultobj = SWIG_Py_Void();
10871  return resultobj;
10872 fail:
10873  return NULL;
10874 }
10875 
10876 
10877 SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878  PyObject *resultobj = 0;
10879  PLINT arg1 ;
10880  int val1 ;
10881  int ecode1 = 0 ;
10882  PyObject *swig_obj[1] ;
10883 
10884  if (!args) SWIG_fail;
10885  swig_obj[0] = args;
10886  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10887  if (!SWIG_IsOK(ecode1)) {
10888  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10889  }
10890  arg1 = (PLINT)(val1);
10891  plscompression(arg1);
10892  resultobj = SWIG_Py_Void();
10893  return resultobj;
10894 fail:
10895  return NULL;
10896 }
10897 
10898 
10899 SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10900  PyObject *resultobj = 0;
10901  char *arg1 = (char *) 0 ;
10902  int res1 ;
10903  char *buf1 = 0 ;
10904  int alloc1 = 0 ;
10905  PyObject *swig_obj[1] ;
10906 
10907  if (!args) SWIG_fail;
10908  swig_obj[0] = args;
10909  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10910  if (!SWIG_IsOK(res1)) {
10911  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10912  }
10913  arg1 = (char *)(buf1);
10914  plsdev((char const *)arg1);
10915  resultobj = SWIG_Py_Void();
10916  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10917  return resultobj;
10918 fail:
10919  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10920  return NULL;
10921 }
10922 
10923 
10924 SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10925  PyObject *resultobj = 0;
10926  PLFLT arg1 ;
10927  PLFLT arg2 ;
10928  PLFLT arg3 ;
10929  PLFLT arg4 ;
10930  double val1 ;
10931  int ecode1 = 0 ;
10932  double val2 ;
10933  int ecode2 = 0 ;
10934  double val3 ;
10935  int ecode3 = 0 ;
10936  double val4 ;
10937  int ecode4 = 0 ;
10938  PyObject *swig_obj[4] ;
10939 
10940  if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
10941  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10942  if (!SWIG_IsOK(ecode1)) {
10943  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10944  }
10945  arg1 = (PLFLT)(val1);
10946  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10947  if (!SWIG_IsOK(ecode2)) {
10948  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10949  }
10950  arg2 = (PLFLT)(val2);
10951  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10952  if (!SWIG_IsOK(ecode3)) {
10953  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10954  }
10955  arg3 = (PLFLT)(val3);
10956  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10957  if (!SWIG_IsOK(ecode4)) {
10958  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10959  }
10960  arg4 = (PLFLT)(val4);
10961  plsdidev(arg1,arg2,arg3,arg4);
10962  resultobj = SWIG_Py_Void();
10963  return resultobj;
10964 fail:
10965  return NULL;
10966 }
10967 
10968 
10969 SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10970  PyObject *resultobj = 0;
10971  PLINT arg1 ;
10972  PLINT arg2 ;
10973  PLINT arg3 ;
10974  PLINT arg4 ;
10975  PLFLT arg5 ;
10976  PLFLT arg6 ;
10977  int val1 ;
10978  int ecode1 = 0 ;
10979  int val2 ;
10980  int ecode2 = 0 ;
10981  int val3 ;
10982  int ecode3 = 0 ;
10983  int val4 ;
10984  int ecode4 = 0 ;
10985  double val5 ;
10986  int ecode5 = 0 ;
10987  double val6 ;
10988  int ecode6 = 0 ;
10989  PyObject *swig_obj[6] ;
10990 
10991  if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
10992  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10993  if (!SWIG_IsOK(ecode1)) {
10994  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
10995  }
10996  arg1 = (PLINT)(val1);
10997  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10998  if (!SWIG_IsOK(ecode2)) {
10999  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11000  }
11001  arg2 = (PLINT)(val2);
11002  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11003  if (!SWIG_IsOK(ecode3)) {
11004  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11005  }
11006  arg3 = (PLINT)(val3);
11007  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11008  if (!SWIG_IsOK(ecode4)) {
11009  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11010  }
11011  arg4 = (PLINT)(val4);
11012  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11013  if (!SWIG_IsOK(ecode5)) {
11014  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11015  }
11016  arg5 = (PLFLT)(val5);
11017  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11018  if (!SWIG_IsOK(ecode6)) {
11019  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11020  }
11021  arg6 = (PLFLT)(val6);
11022  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11023  resultobj = SWIG_Py_Void();
11024  return resultobj;
11025 fail:
11026  return NULL;
11027 }
11028 
11029 
11030 SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11031  PyObject *resultobj = 0;
11032  PLFLT arg1 ;
11033  double val1 ;
11034  int ecode1 = 0 ;
11035  PyObject *swig_obj[1] ;
11036 
11037  if (!args) SWIG_fail;
11038  swig_obj[0] = args;
11039  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11040  if (!SWIG_IsOK(ecode1)) {
11041  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11042  }
11043  arg1 = (PLFLT)(val1);
11044  plsdiori(arg1);
11045  resultobj = SWIG_Py_Void();
11046  return resultobj;
11047 fail:
11048  return NULL;
11049 }
11050 
11051 
11052 SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11053  PyObject *resultobj = 0;
11054  PLFLT arg1 ;
11055  PLFLT arg2 ;
11056  PLFLT arg3 ;
11057  PLFLT arg4 ;
11058  double val1 ;
11059  int ecode1 = 0 ;
11060  double val2 ;
11061  int ecode2 = 0 ;
11062  double val3 ;
11063  int ecode3 = 0 ;
11064  double val4 ;
11065  int ecode4 = 0 ;
11066  PyObject *swig_obj[4] ;
11067 
11068  if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11069  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11070  if (!SWIG_IsOK(ecode1)) {
11071  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11072  }
11073  arg1 = (PLFLT)(val1);
11074  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11075  if (!SWIG_IsOK(ecode2)) {
11076  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11077  }
11078  arg2 = (PLFLT)(val2);
11079  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11080  if (!SWIG_IsOK(ecode3)) {
11081  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11082  }
11083  arg3 = (PLFLT)(val3);
11084  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11085  if (!SWIG_IsOK(ecode4)) {
11086  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11087  }
11088  arg4 = (PLFLT)(val4);
11089  plsdiplt(arg1,arg2,arg3,arg4);
11090  resultobj = SWIG_Py_Void();
11091  return resultobj;
11092 fail:
11093  return NULL;
11094 }
11095 
11096 
11097 SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098  PyObject *resultobj = 0;
11099  PLFLT arg1 ;
11100  PLFLT arg2 ;
11101  PLFLT arg3 ;
11102  PLFLT arg4 ;
11103  double val1 ;
11104  int ecode1 = 0 ;
11105  double val2 ;
11106  int ecode2 = 0 ;
11107  double val3 ;
11108  int ecode3 = 0 ;
11109  double val4 ;
11110  int ecode4 = 0 ;
11111  PyObject *swig_obj[4] ;
11112 
11113  if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11114  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11115  if (!SWIG_IsOK(ecode1)) {
11116  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11117  }
11118  arg1 = (PLFLT)(val1);
11119  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11120  if (!SWIG_IsOK(ecode2)) {
11121  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11122  }
11123  arg2 = (PLFLT)(val2);
11124  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11125  if (!SWIG_IsOK(ecode3)) {
11126  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11127  }
11128  arg3 = (PLFLT)(val3);
11129  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11130  if (!SWIG_IsOK(ecode4)) {
11131  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11132  }
11133  arg4 = (PLFLT)(val4);
11134  plsdiplz(arg1,arg2,arg3,arg4);
11135  resultobj = SWIG_Py_Void();
11136  return resultobj;
11137 fail:
11138  return NULL;
11139 }
11140 
11141 
11142 SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11143  PyObject *resultobj = 0;
11144  unsigned int arg1 ;
11145  unsigned int val1 ;
11146  int ecode1 = 0 ;
11147  PyObject *swig_obj[1] ;
11148 
11149  if (!args) SWIG_fail;
11150  swig_obj[0] = args;
11151  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11152  if (!SWIG_IsOK(ecode1)) {
11153  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11154  }
11155  arg1 = (unsigned int)(val1);
11156  plseed(arg1);
11157  resultobj = SWIG_Py_Void();
11158  return resultobj;
11159 fail:
11160  return NULL;
11161 }
11162 
11163 
11164 SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11165  PyObject *resultobj = 0;
11166  char arg1 ;
11167  char val1 ;
11168  int ecode1 = 0 ;
11169  PyObject *swig_obj[1] ;
11170 
11171  if (!args) SWIG_fail;
11172  swig_obj[0] = args;
11173  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11174  if (!SWIG_IsOK(ecode1)) {
11175  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11176  }
11177  arg1 = (char)(val1);
11178  plsesc(arg1);
11179  resultobj = SWIG_Py_Void();
11180  return resultobj;
11181 fail:
11182  return NULL;
11183 }
11184 
11185 
11186 SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187  PyObject *resultobj = 0;
11188  char *arg1 = (char *) 0 ;
11189  char *arg2 = (char *) 0 ;
11190  int res1 ;
11191  char *buf1 = 0 ;
11192  int alloc1 = 0 ;
11193  int res2 ;
11194  char *buf2 = 0 ;
11195  int alloc2 = 0 ;
11196  PyObject *swig_obj[2] ;
11197  PLINT result;
11198 
11199  if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11200  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11201  if (!SWIG_IsOK(res1)) {
11202  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11203  }
11204  arg1 = (char *)(buf1);
11205  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11206  if (!SWIG_IsOK(res2)) {
11207  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11208  }
11209  arg2 = (char *)(buf2);
11210  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11211  resultobj = SWIG_From_int((int)(result));
11212  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11213  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11214  return resultobj;
11215 fail:
11216  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11217  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11218  return NULL;
11219 }
11220 
11221 
11222 SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11223  PyObject *resultobj = 0;
11224  PLINT arg1 ;
11225  PLINT arg2 ;
11226  PLINT arg3 ;
11227  int val1 ;
11228  int ecode1 = 0 ;
11229  int val2 ;
11230  int ecode2 = 0 ;
11231  int val3 ;
11232  int ecode3 = 0 ;
11233  PyObject *swig_obj[3] ;
11234 
11235  if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11236  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11237  if (!SWIG_IsOK(ecode1)) {
11238  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11239  }
11240  arg1 = (PLINT)(val1);
11241  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11242  if (!SWIG_IsOK(ecode2)) {
11243  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11244  }
11245  arg2 = (PLINT)(val2);
11246  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11247  if (!SWIG_IsOK(ecode3)) {
11248  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11249  }
11250  arg3 = (PLINT)(val3);
11251  plsfam(arg1,arg2,arg3);
11252  resultobj = SWIG_Py_Void();
11253  return resultobj;
11254 fail:
11255  return NULL;
11256 }
11257 
11258 
11259 SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11260  PyObject *resultobj = 0;
11261  PLUNICODE arg1 ;
11262  unsigned int val1 ;
11263  int ecode1 = 0 ;
11264  PyObject *swig_obj[1] ;
11265 
11266  if (!args) SWIG_fail;
11267  swig_obj[0] = args;
11268  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11269  if (!SWIG_IsOK(ecode1)) {
11270  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11271  }
11272  arg1 = (PLUNICODE)(val1);
11273  plsfci(arg1);
11274  resultobj = SWIG_Py_Void();
11275  return resultobj;
11276 fail:
11277  return NULL;
11278 }
11279 
11280 
11281 SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282  PyObject *resultobj = 0;
11283  char *arg1 = (char *) 0 ;
11284  int res1 ;
11285  char *buf1 = 0 ;
11286  int alloc1 = 0 ;
11287  PyObject *swig_obj[1] ;
11288 
11289  if (!args) SWIG_fail;
11290  swig_obj[0] = args;
11291  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11292  if (!SWIG_IsOK(res1)) {
11293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11294  }
11295  arg1 = (char *)(buf1);
11296  plsfnam((char const *)arg1);
11297  resultobj = SWIG_Py_Void();
11298  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11299  return resultobj;
11300 fail:
11301  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11302  return NULL;
11303 }
11304 
11305 
11306 SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11307  PyObject *resultobj = 0;
11308  PLINT arg1 ;
11309  PLINT arg2 ;
11310  PLINT arg3 ;
11311  int val1 ;
11312  int ecode1 = 0 ;
11313  int val2 ;
11314  int ecode2 = 0 ;
11315  int val3 ;
11316  int ecode3 = 0 ;
11317  PyObject *swig_obj[3] ;
11318 
11319  if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11320  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11321  if (!SWIG_IsOK(ecode1)) {
11322  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11323  }
11324  arg1 = (PLINT)(val1);
11325  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11326  if (!SWIG_IsOK(ecode2)) {
11327  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11328  }
11329  arg2 = (PLINT)(val2);
11330  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11331  if (!SWIG_IsOK(ecode3)) {
11332  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11333  }
11334  arg3 = (PLINT)(val3);
11335  plsfont(arg1,arg2,arg3);
11336  resultobj = SWIG_Py_Void();
11337  return resultobj;
11338 fail:
11339  return NULL;
11340 }
11341 
11342 
11343 SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11344  PyObject *resultobj = 0;
11345  PLFLT **arg1 = (PLFLT **) 0 ;
11346  PLINT arg2 ;
11347  PLINT arg3 ;
11348  defined_func arg4 = (defined_func) 0 ;
11349  PLFLT arg5 ;
11350  PLFLT arg6 ;
11351  PLFLT arg7 ;
11352  PLFLT arg8 ;
11353  PLFLT *arg9 = (PLFLT *) 0 ;
11354  PLINT arg10 ;
11355  PLFLT arg11 ;
11356  PLINT arg12 ;
11357  PLFLT arg13 ;
11358  fill_func arg14 = (fill_func) 0 ;
11359  PLBOOL arg15 ;
11360  pltr_func arg16 = (pltr_func) 0 ;
11361  PLPointer arg17 = (PLPointer) 0 ;
11362  PyArrayObject *tmp1 = NULL ;
11363  double val5 ;
11364  int ecode5 = 0 ;
11365  double val6 ;
11366  int ecode6 = 0 ;
11367  double val7 ;
11368  int ecode7 = 0 ;
11369  double val8 ;
11370  int ecode8 = 0 ;
11371  PyArrayObject *tmp9 = NULL ;
11372  double val11 ;
11373  int ecode11 = 0 ;
11374  int val12 ;
11375  int ecode12 = 0 ;
11376  double val13 ;
11377  int ecode13 = 0 ;
11378  int val15 ;
11379  int ecode15 = 0 ;
11380  PyObject *swig_obj[12] ;
11381 
11382  {
11383  python_pltr = 0;
11384  arg16 = NULL;
11385  }
11386  {
11387  arg17 = NULL;
11388  }
11389  {
11390  arg4 = NULL;
11391  }
11392  {
11393  arg14 = plfill;
11394  }
11395  if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
11396  {
11397  int i, size;
11398  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11399  if ( tmp1 == NULL )
11400  return NULL;
11401  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11402  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11403  size = arg3;
11404  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11405  for ( i = 0; i < arg2; i++ )
11406  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11407  }
11408  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11409  if (!SWIG_IsOK(ecode5)) {
11410  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11411  }
11412  arg5 = (PLFLT)(val5);
11413  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11414  if (!SWIG_IsOK(ecode6)) {
11415  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11416  }
11417  arg6 = (PLFLT)(val6);
11418  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11419  if (!SWIG_IsOK(ecode7)) {
11420  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11421  }
11422  arg7 = (PLFLT)(val7);
11423  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11424  if (!SWIG_IsOK(ecode8)) {
11425  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11426  }
11427  arg8 = (PLFLT)(val8);
11428  {
11429  tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11430  if ( tmp9 == NULL )
11431  return NULL;
11432  arg10 = PyArray_DIMS( tmp9 )[0];
11433  arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11434  }
11435  ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
11436  if (!SWIG_IsOK(ecode11)) {
11437  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11438  }
11439  arg11 = (PLFLT)(val11);
11440  ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
11441  if (!SWIG_IsOK(ecode12)) {
11442  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11443  }
11444  arg12 = (PLINT)(val12);
11445  ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
11446  if (!SWIG_IsOK(ecode13)) {
11447  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11448  }
11449  arg13 = (PLFLT)(val13);
11450  ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
11451  if (!SWIG_IsOK(ecode15)) {
11452  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11453  }
11454  arg15 = (PLBOOL)(val15);
11455  if (swig_obj[10]) {
11456  {
11457  // it must be a callable or None
11458  if ( swig_obj[10] == Py_None )
11459  {
11460  arg16 = NULL;
11461  }
11462  else
11463  {
11464  if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
11465  {
11466  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11467  return NULL;
11468  }
11469  arg16 = marshal_pltr( swig_obj[10] );
11470  }
11471  }
11472  }
11473  if (swig_obj[11]) {
11474  {
11475  if ( swig_obj[11] == Py_None )
11476  arg17 = NULL;
11477  else
11478  {
11479  arg17 = marshal_PLPointer( swig_obj[11], 0 );
11480  }
11481  }
11482  }
11483  plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11484  resultobj = SWIG_Py_Void();
11485  {
11486  Py_CLEAR( tmp1 );
11487  free( arg1 );
11488  }
11489  {
11490  Py_CLEAR( tmp9 );
11491  }
11492  {
11493  cleanup_pltr();
11494  }
11495  {
11497  }
11498  return resultobj;
11499 fail:
11500  {
11501  Py_CLEAR( tmp1 );
11502  free( arg1 );
11503  }
11504  {
11505  Py_CLEAR( tmp9 );
11506  }
11507  {
11508  cleanup_pltr();
11509  }
11510  {
11512  }
11513  return NULL;
11514 }
11515 
11516 
11517 SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11518  PyObject *resultobj = 0;
11519  PLFLT **arg1 = (PLFLT **) 0 ;
11520  PLINT arg2 ;
11521  PLINT arg3 ;
11522  defined_func arg4 = (defined_func) 0 ;
11523  PLFLT arg5 ;
11524  PLFLT arg6 ;
11525  PLFLT arg7 ;
11526  PLFLT arg8 ;
11527  PLFLT arg9 ;
11528  PLFLT arg10 ;
11529  PLINT arg11 ;
11530  PLFLT arg12 ;
11531  PLFLT arg13 ;
11532  PLINT arg14 ;
11533  PLFLT arg15 ;
11534  PLINT arg16 ;
11535  PLFLT arg17 ;
11536  fill_func arg18 = (fill_func) 0 ;
11537  PLBOOL arg19 ;
11538  pltr_func arg20 = (pltr_func) 0 ;
11539  PLPointer arg21 = (PLPointer) 0 ;
11540  PyArrayObject *tmp1 = NULL ;
11541  double val5 ;
11542  int ecode5 = 0 ;
11543  double val6 ;
11544  int ecode6 = 0 ;
11545  double val7 ;
11546  int ecode7 = 0 ;
11547  double val8 ;
11548  int ecode8 = 0 ;
11549  double val9 ;
11550  int ecode9 = 0 ;
11551  double val10 ;
11552  int ecode10 = 0 ;
11553  int val11 ;
11554  int ecode11 = 0 ;
11555  double val12 ;
11556  int ecode12 = 0 ;
11557  double val13 ;
11558  int ecode13 = 0 ;
11559  int val14 ;
11560  int ecode14 = 0 ;
11561  double val15 ;
11562  int ecode15 = 0 ;
11563  int val16 ;
11564  int ecode16 = 0 ;
11565  double val17 ;
11566  int ecode17 = 0 ;
11567  int val19 ;
11568  int ecode19 = 0 ;
11569  PyObject *swig_obj[17] ;
11570 
11571  {
11572  python_pltr = 0;
11573  arg20 = NULL;
11574  }
11575  {
11576  arg21 = NULL;
11577  }
11578  {
11579  arg4 = NULL;
11580  }
11581  {
11582  arg18 = plfill;
11583  }
11584  if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
11585  {
11586  int i, size;
11587  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11588  if ( tmp1 == NULL )
11589  return NULL;
11590  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11591  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11592  size = arg3;
11593  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11594  for ( i = 0; i < arg2; i++ )
11595  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11596  }
11597  ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11598  if (!SWIG_IsOK(ecode5)) {
11599  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11600  }
11601  arg5 = (PLFLT)(val5);
11602  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11603  if (!SWIG_IsOK(ecode6)) {
11604  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11605  }
11606  arg6 = (PLFLT)(val6);
11607  ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11608  if (!SWIG_IsOK(ecode7)) {
11609  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11610  }
11611  arg7 = (PLFLT)(val7);
11612  ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11613  if (!SWIG_IsOK(ecode8)) {
11614  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11615  }
11616  arg8 = (PLFLT)(val8);
11617  ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
11618  if (!SWIG_IsOK(ecode9)) {
11619  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11620  }
11621  arg9 = (PLFLT)(val9);
11622  ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
11623  if (!SWIG_IsOK(ecode10)) {
11624  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11625  }
11626  arg10 = (PLFLT)(val10);
11627  ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
11628  if (!SWIG_IsOK(ecode11)) {
11629  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11630  }
11631  arg11 = (PLINT)(val11);
11632  ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
11633  if (!SWIG_IsOK(ecode12)) {
11634  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11635  }
11636  arg12 = (PLFLT)(val12);
11637  ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
11638  if (!SWIG_IsOK(ecode13)) {
11639  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
11640  }
11641  arg13 = (PLFLT)(val13);
11642  ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
11643  if (!SWIG_IsOK(ecode14)) {
11644  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11645  }
11646  arg14 = (PLINT)(val14);
11647  ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
11648  if (!SWIG_IsOK(ecode15)) {
11649  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
11650  }
11651  arg15 = (PLFLT)(val15);
11652  ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
11653  if (!SWIG_IsOK(ecode16)) {
11654  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11655  }
11656  arg16 = (PLINT)(val16);
11657  ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
11658  if (!SWIG_IsOK(ecode17)) {
11659  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
11660  }
11661  arg17 = (PLFLT)(val17);
11662  ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
11663  if (!SWIG_IsOK(ecode19)) {
11664  SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11665  }
11666  arg19 = (PLBOOL)(val19);
11667  if (swig_obj[15]) {
11668  {
11669  // it must be a callable or None
11670  if ( swig_obj[15] == Py_None )
11671  {
11672  arg20 = NULL;
11673  }
11674  else
11675  {
11676  if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
11677  {
11678  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11679  return NULL;
11680  }
11681  arg20 = marshal_pltr( swig_obj[15] );
11682  }
11683  }
11684  }
11685  if (swig_obj[16]) {
11686  {
11687  if ( swig_obj[16] == Py_None )
11688  arg21 = NULL;
11689  else
11690  {
11691  arg21 = marshal_PLPointer( swig_obj[16], 0 );
11692  }
11693  }
11694  }
11695  plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11696  resultobj = SWIG_Py_Void();
11697  {
11698  Py_CLEAR( tmp1 );
11699  free( arg1 );
11700  }
11701  {
11702  cleanup_pltr();
11703  }
11704  {
11706  }
11707  return resultobj;
11708 fail:
11709  {
11710  Py_CLEAR( tmp1 );
11711  free( arg1 );
11712  }
11713  {
11714  cleanup_pltr();
11715  }
11716  {
11718  }
11719  return NULL;
11720 }
11721 
11722 
11723 SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724  PyObject *resultobj = 0;
11725  label_func arg1 = (label_func) 0 ;
11726  PLPointer arg2 = (PLPointer) 0 ;
11727  int res2 ;
11728  PyObject *swig_obj[2] ;
11729 
11730  if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
11731  {
11732  // Release reference to previous function if applicable
11733  if ( python_label )
11734  {
11735  Py_CLEAR( python_label );
11736  python_label = 0;
11737  }
11738  // it must be a callable or None
11739  if ( swig_obj[0] == Py_None )
11740  {
11741  arg1 = NULL;
11742  }
11743  else
11744  {
11745  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
11746  {
11747  PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11748  return NULL;
11749  }
11750  // hold a reference to it
11751  Py_XINCREF( (PyObject *) swig_obj[0] );
11752  python_label = (PyObject *) swig_obj[0];
11753  // this function handles calling the python function
11754  arg1 = do_label_callback;
11755  }
11756  }
11757  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
11758  if (!SWIG_IsOK(res2)) {
11759  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
11760  }
11761  plslabelfunc(arg1,arg2);
11762  resultobj = SWIG_Py_Void();
11763  return resultobj;
11764 fail:
11765  return NULL;
11766 }
11767 
11768 
11769 SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11770  PyObject *resultobj = 0;
11771  PLFLT arg1 ;
11772  PLFLT arg2 ;
11773  double val1 ;
11774  int ecode1 = 0 ;
11775  double val2 ;
11776  int ecode2 = 0 ;
11777  PyObject *swig_obj[2] ;
11778 
11779  if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
11780  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11781  if (!SWIG_IsOK(ecode1)) {
11782  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11783  }
11784  arg1 = (PLFLT)(val1);
11785  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11786  if (!SWIG_IsOK(ecode2)) {
11787  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11788  }
11789  arg2 = (PLFLT)(val2);
11790  plsmaj(arg1,arg2);
11791  resultobj = SWIG_Py_Void();
11792  return resultobj;
11793 fail:
11794  return NULL;
11795 }
11796 
11797 
11798 SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11799  PyObject *resultobj = 0;
11800  PLINT arg1 ;
11801  PLINT arg2 ;
11802  void *arg3 = (void *) 0 ;
11803  int val1 ;
11804  int ecode1 = 0 ;
11805  int val2 ;
11806  int ecode2 = 0 ;
11807  PyObject *swig_obj[3] ;
11808 
11809  if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
11810  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11811  if (!SWIG_IsOK(ecode1)) {
11812  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11813  }
11814  arg1 = (PLINT)(val1);
11815  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11816  if (!SWIG_IsOK(ecode2)) {
11817  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11818  }
11819  arg2 = (PLINT)(val2);
11820  {
11821  int res; void *buf = 0;
11822  Py_buffer view;
11823  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11824  buf = view.buf;
11825  PyBuffer_Release(&view);
11826  if (res < 0) {
11827  PyErr_Clear();
11828  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
11829  }
11830  arg3 = (void *) buf;
11831  }
11832  plsmem(arg1,arg2,arg3);
11833  resultobj = SWIG_Py_Void();
11834  return resultobj;
11835 fail:
11836  return NULL;
11837 }
11838 
11839 
11840 SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11841  PyObject *resultobj = 0;
11842  PLINT arg1 ;
11843  PLINT arg2 ;
11844  void *arg3 = (void *) 0 ;
11845  int val1 ;
11846  int ecode1 = 0 ;
11847  int val2 ;
11848  int ecode2 = 0 ;
11849  PyObject *swig_obj[3] ;
11850 
11851  if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
11852  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11853  if (!SWIG_IsOK(ecode1)) {
11854  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11855  }
11856  arg1 = (PLINT)(val1);
11857  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11858  if (!SWIG_IsOK(ecode2)) {
11859  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11860  }
11861  arg2 = (PLINT)(val2);
11862  {
11863  int res; void *buf = 0;
11864  Py_buffer view;
11865  res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11866  buf = view.buf;
11867  PyBuffer_Release(&view);
11868  if (res < 0) {
11869  PyErr_Clear();
11870  SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
11871  }
11872  arg3 = (void *) buf;
11873  }
11874  plsmema(arg1,arg2,arg3);
11875  resultobj = SWIG_Py_Void();
11876  return resultobj;
11877 fail:
11878  return NULL;
11879 }
11880 
11881 
11882 SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11883  PyObject *resultobj = 0;
11884  PLFLT arg1 ;
11885  PLFLT arg2 ;
11886  double val1 ;
11887  int ecode1 = 0 ;
11888  double val2 ;
11889  int ecode2 = 0 ;
11890  PyObject *swig_obj[2] ;
11891 
11892  if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
11893  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11894  if (!SWIG_IsOK(ecode1)) {
11895  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11896  }
11897  arg1 = (PLFLT)(val1);
11898  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11899  if (!SWIG_IsOK(ecode2)) {
11900  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11901  }
11902  arg2 = (PLFLT)(val2);
11903  plsmin(arg1,arg2);
11904  resultobj = SWIG_Py_Void();
11905  return resultobj;
11906 fail:
11907  return NULL;
11908 }
11909 
11910 
11911 SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11912  PyObject *resultobj = 0;
11913  PLINT arg1 ;
11914  int val1 ;
11915  int ecode1 = 0 ;
11916  PyObject *swig_obj[1] ;
11917 
11918  if (!args) SWIG_fail;
11919  swig_obj[0] = args;
11920  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11921  if (!SWIG_IsOK(ecode1)) {
11922  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11923  }
11924  arg1 = (PLINT)(val1);
11925  plsori(arg1);
11926  resultobj = SWIG_Py_Void();
11927  return resultobj;
11928 fail:
11929  return NULL;
11930 }
11931 
11932 
11933 SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11934  PyObject *resultobj = 0;
11935  PLFLT arg1 ;
11936  PLFLT arg2 ;
11937  PLINT arg3 ;
11938  PLINT arg4 ;
11939  PLINT arg5 ;
11940  PLINT arg6 ;
11941  double val1 ;
11942  int ecode1 = 0 ;
11943  double val2 ;
11944  int ecode2 = 0 ;
11945  int val3 ;
11946  int ecode3 = 0 ;
11947  int val4 ;
11948  int ecode4 = 0 ;
11949  int val5 ;
11950  int ecode5 = 0 ;
11951  int val6 ;
11952  int ecode6 = 0 ;
11953  PyObject *swig_obj[6] ;
11954 
11955  if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
11956  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11957  if (!SWIG_IsOK(ecode1)) {
11958  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11959  }
11960  arg1 = (PLFLT)(val1);
11961  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11962  if (!SWIG_IsOK(ecode2)) {
11963  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11964  }
11965  arg2 = (PLFLT)(val2);
11966  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11967  if (!SWIG_IsOK(ecode3)) {
11968  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
11969  }
11970  arg3 = (PLINT)(val3);
11971  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11972  if (!SWIG_IsOK(ecode4)) {
11973  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
11974  }
11975  arg4 = (PLINT)(val4);
11976  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
11977  if (!SWIG_IsOK(ecode5)) {
11978  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
11979  }
11980  arg5 = (PLINT)(val5);
11981  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
11982  if (!SWIG_IsOK(ecode6)) {
11983  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
11984  }
11985  arg6 = (PLINT)(val6);
11986  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
11987  resultobj = SWIG_Py_Void();
11988  return resultobj;
11989 fail:
11990  return NULL;
11991 }
11992 
11993 
11994 SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11995  PyObject *resultobj = 0;
11996  char *arg1 = (char *) 0 ;
11997  int res1 ;
11998  char *buf1 = 0 ;
11999  int alloc1 = 0 ;
12000  PyObject *swig_obj[1] ;
12001 
12002  if (!args) SWIG_fail;
12003  swig_obj[0] = args;
12004  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12005  if (!SWIG_IsOK(res1)) {
12006  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12007  }
12008  arg1 = (char *)(buf1);
12009  plspal0((char const *)arg1);
12010  resultobj = SWIG_Py_Void();
12011  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12012  return resultobj;
12013 fail:
12014  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12015  return NULL;
12016 }
12017 
12018 
12019 SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020  PyObject *resultobj = 0;
12021  char *arg1 = (char *) 0 ;
12022  PLBOOL arg2 ;
12023  int res1 ;
12024  char *buf1 = 0 ;
12025  int alloc1 = 0 ;
12026  int val2 ;
12027  int ecode2 = 0 ;
12028  PyObject *swig_obj[2] ;
12029 
12030  if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12031  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12032  if (!SWIG_IsOK(res1)) {
12033  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12034  }
12035  arg1 = (char *)(buf1);
12036  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12037  if (!SWIG_IsOK(ecode2)) {
12038  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12039  }
12040  arg2 = (PLBOOL)(val2);
12041  plspal1((char const *)arg1,arg2);
12042  resultobj = SWIG_Py_Void();
12043  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12044  return resultobj;
12045 fail:
12046  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12047  return NULL;
12048 }
12049 
12050 
12051 SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12052  PyObject *resultobj = 0;
12053  PLBOOL arg1 ;
12054  int val1 ;
12055  int ecode1 = 0 ;
12056  PyObject *swig_obj[1] ;
12057 
12058  if (!args) SWIG_fail;
12059  swig_obj[0] = args;
12060  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12061  if (!SWIG_IsOK(ecode1)) {
12062  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12063  }
12064  arg1 = (PLBOOL)(val1);
12065  plspause(arg1);
12066  resultobj = SWIG_Py_Void();
12067  return resultobj;
12068 fail:
12069  return NULL;
12070 }
12071 
12072 
12073 SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12074  PyObject *resultobj = 0;
12075  PLINT arg1 ;
12076  int val1 ;
12077  int ecode1 = 0 ;
12078  PyObject *swig_obj[1] ;
12079 
12080  if (!args) SWIG_fail;
12081  swig_obj[0] = args;
12082  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12083  if (!SWIG_IsOK(ecode1)) {
12084  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12085  }
12086  arg1 = (PLINT)(val1);
12087  plsstrm(arg1);
12088  resultobj = SWIG_Py_Void();
12089  return resultobj;
12090 fail:
12091  return NULL;
12092 }
12093 
12094 
12095 SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096  PyObject *resultobj = 0;
12097  PLINT arg1 ;
12098  PLINT arg2 ;
12099  int val1 ;
12100  int ecode1 = 0 ;
12101  int val2 ;
12102  int ecode2 = 0 ;
12103  PyObject *swig_obj[2] ;
12104 
12105  if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12106  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12107  if (!SWIG_IsOK(ecode1)) {
12108  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12109  }
12110  arg1 = (PLINT)(val1);
12111  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12112  if (!SWIG_IsOK(ecode2)) {
12113  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12114  }
12115  arg2 = (PLINT)(val2);
12116  plssub(arg1,arg2);
12117  resultobj = SWIG_Py_Void();
12118  return resultobj;
12119 fail:
12120  return NULL;
12121 }
12122 
12123 
12124 SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12125  PyObject *resultobj = 0;
12126  PLFLT arg1 ;
12127  PLFLT arg2 ;
12128  double val1 ;
12129  int ecode1 = 0 ;
12130  double val2 ;
12131  int ecode2 = 0 ;
12132  PyObject *swig_obj[2] ;
12133 
12134  if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12135  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12136  if (!SWIG_IsOK(ecode1)) {
12137  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12138  }
12139  arg1 = (PLFLT)(val1);
12140  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12141  if (!SWIG_IsOK(ecode2)) {
12142  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12143  }
12144  arg2 = (PLFLT)(val2);
12145  plssym(arg1,arg2);
12146  resultobj = SWIG_Py_Void();
12147  return resultobj;
12148 fail:
12149  return NULL;
12150 }
12151 
12152 
12153 SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154  PyObject *resultobj = 0;
12155  PLINT arg1 ;
12156  PLINT arg2 ;
12157  int val1 ;
12158  int ecode1 = 0 ;
12159  int val2 ;
12160  int ecode2 = 0 ;
12161  PyObject *swig_obj[2] ;
12162 
12163  if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12164  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12165  if (!SWIG_IsOK(ecode1)) {
12166  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12167  }
12168  arg1 = (PLINT)(val1);
12169  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12170  if (!SWIG_IsOK(ecode2)) {
12171  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12172  }
12173  arg2 = (PLINT)(val2);
12174  plstar(arg1,arg2);
12175  resultobj = SWIG_Py_Void();
12176  return resultobj;
12177 fail:
12178  return NULL;
12179 }
12180 
12181 
12182 SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183  PyObject *resultobj = 0;
12184  char *arg1 = (char *) 0 ;
12185  PLINT arg2 ;
12186  PLINT arg3 ;
12187  int res1 ;
12188  char *buf1 = 0 ;
12189  int alloc1 = 0 ;
12190  int val2 ;
12191  int ecode2 = 0 ;
12192  int val3 ;
12193  int ecode3 = 0 ;
12194  PyObject *swig_obj[3] ;
12195 
12196  if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12197  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12198  if (!SWIG_IsOK(res1)) {
12199  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12200  }
12201  arg1 = (char *)(buf1);
12202  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12203  if (!SWIG_IsOK(ecode2)) {
12204  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12205  }
12206  arg2 = (PLINT)(val2);
12207  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12208  if (!SWIG_IsOK(ecode3)) {
12209  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12210  }
12211  arg3 = (PLINT)(val3);
12212  plstart((char const *)arg1,arg2,arg3);
12213  resultobj = SWIG_Py_Void();
12214  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12215  return resultobj;
12216 fail:
12217  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12218  return NULL;
12219 }
12220 
12221 
12222 SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12223  PyObject *resultobj = 0;
12224  ct_func arg1 = (ct_func) 0 ;
12225  PLPointer arg2 = (PLPointer) 0 ;
12226  int res2 ;
12227  PyObject *swig_obj[2] ;
12228 
12229  {
12230  python_ct = 0;
12231  arg1 = NULL;
12232  }
12233  if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12234  if (swig_obj[0]) {
12235  {
12236  if ( python_ct )
12237  cleanup_ct();
12238  // it must be a callable or none
12239  if ( swig_obj[0] == Py_None )
12240  {
12241  arg1 = NULL;
12242  }
12243  else
12244  {
12245  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12246  {
12247  PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12248  return NULL;
12249  }
12250  arg1 = marshal_ct( swig_obj[0] );
12251  }
12252  }
12253  }
12254  if (swig_obj[1]) {
12255  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12256  if (!SWIG_IsOK(res2)) {
12257  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12258  }
12259  }
12260  plstransform(arg1,arg2);
12261  resultobj = SWIG_Py_Void();
12262  return resultobj;
12263 fail:
12264  return NULL;
12265 }
12266 
12267 
12268 SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269  PyObject *resultobj = 0;
12270  PLINT arg1 ;
12271  PLFLT *arg2 = (PLFLT *) 0 ;
12272  PLFLT *arg3 = (PLFLT *) 0 ;
12273  char *arg4 = (char *) 0 ;
12274  PyArrayObject *tmp1 = NULL ;
12275  PyArrayObject *tmp3 = NULL ;
12276  int res4 ;
12277  char *buf4 = 0 ;
12278  int alloc4 = 0 ;
12279  PyObject *swig_obj[3] ;
12280 
12281  if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
12282  {
12283  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12284  if ( tmp1 == NULL )
12285  return NULL;
12286  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12287  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12288  }
12289  {
12290  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12291  if ( tmp3 == NULL )
12292  return NULL;
12293  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12294  {
12295  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12296  return NULL;
12297  }
12298  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12299  }
12300  res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
12301  if (!SWIG_IsOK(res4)) {
12302  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12303  }
12304  arg4 = (char *)(buf4);
12305  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12306  resultobj = SWIG_Py_Void();
12307  {
12308  Py_CLEAR( tmp1 );
12309  }
12310  {
12311  Py_CLEAR( tmp3 );
12312  }
12313  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12314  return resultobj;
12315 fail:
12316  {
12317  Py_CLEAR( tmp1 );
12318  }
12319  {
12320  Py_CLEAR( tmp3 );
12321  }
12322  if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12323  return NULL;
12324 }
12325 
12326 
12327 SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12328  PyObject *resultobj = 0;
12329  PLINT arg1 ;
12330  PLFLT *arg2 = (PLFLT *) 0 ;
12331  PLFLT *arg3 = (PLFLT *) 0 ;
12332  PLFLT *arg4 = (PLFLT *) 0 ;
12333  char *arg5 = (char *) 0 ;
12334  PyArrayObject *tmp1 = NULL ;
12335  PyArrayObject *tmp3 = NULL ;
12336  PyArrayObject *tmp4 = NULL ;
12337  int res5 ;
12338  char *buf5 = 0 ;
12339  int alloc5 = 0 ;
12340  PyObject *swig_obj[4] ;
12341 
12342  if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
12343  {
12344  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12345  if ( tmp1 == NULL )
12346  return NULL;
12347  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12348  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12349  }
12350  {
12351  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12352  if ( tmp3 == NULL )
12353  return NULL;
12354  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12355  {
12356  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12357  return NULL;
12358  }
12359  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12360  }
12361  {
12362  tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
12363  if ( tmp4 == NULL )
12364  return NULL;
12365  if ( PyArray_DIMS( tmp4 )[0] != Alen )
12366  {
12367  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12368  return NULL;
12369  }
12370  arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12371  }
12372  res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
12373  if (!SWIG_IsOK(res5)) {
12374  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12375  }
12376  arg5 = (char *)(buf5);
12377  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12378  resultobj = SWIG_Py_Void();
12379  {
12380  Py_CLEAR( tmp1 );
12381  }
12382  {
12383  Py_CLEAR( tmp3 );
12384  }
12385  {
12386  Py_CLEAR( tmp4 );
12387  }
12388  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12389  return resultobj;
12390 fail:
12391  {
12392  Py_CLEAR( tmp1 );
12393  }
12394  {
12395  Py_CLEAR( tmp3 );
12396  }
12397  {
12398  Py_CLEAR( tmp4 );
12399  }
12400  if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12401  return NULL;
12402 }
12403 
12404 
12405 SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406  PyObject *resultobj = 0;
12407  PLINT arg1 ;
12408  PLINT arg2 ;
12409  PLFLT arg3 ;
12410  PLFLT arg4 ;
12411  int val1 ;
12412  int ecode1 = 0 ;
12413  int val2 ;
12414  int ecode2 = 0 ;
12415  double val3 ;
12416  int ecode3 = 0 ;
12417  double val4 ;
12418  int ecode4 = 0 ;
12419  PyObject *swig_obj[4] ;
12420 
12421  if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
12422  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12423  if (!SWIG_IsOK(ecode1)) {
12424  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12425  }
12426  arg1 = (PLINT)(val1);
12427  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12428  if (!SWIG_IsOK(ecode2)) {
12429  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12430  }
12431  arg2 = (PLINT)(val2);
12432  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12433  if (!SWIG_IsOK(ecode3)) {
12434  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12435  }
12436  arg3 = (PLFLT)(val3);
12437  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12438  if (!SWIG_IsOK(ecode4)) {
12439  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12440  }
12441  arg4 = (PLFLT)(val4);
12442  plstripa(arg1,arg2,arg3,arg4);
12443  resultobj = SWIG_Py_Void();
12444  return resultobj;
12445 fail:
12446  return NULL;
12447 }
12448 
12449 
12450 SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12451  PyObject *resultobj = 0;
12452  PLINT *arg1 = (PLINT *) 0 ;
12453  char *arg2 = (char *) 0 ;
12454  char *arg3 = (char *) 0 ;
12455  PLFLT arg4 ;
12456  PLFLT arg5 ;
12457  PLFLT arg6 ;
12458  PLFLT arg7 ;
12459  PLFLT arg8 ;
12460  PLFLT arg9 ;
12461  PLFLT arg10 ;
12462  PLBOOL arg11 ;
12463  PLBOOL arg12 ;
12464  PLINT arg13 ;
12465  PLINT arg14 ;
12466  PLINT *arg15 = (PLINT *) 0 ;
12467  PLINT *arg16 = (PLINT *) 0 ;
12468  char **arg17 ;
12469  char *arg18 = (char *) 0 ;
12470  char *arg19 = (char *) 0 ;
12471  char *arg20 = (char *) 0 ;
12472  PLINT temp1 ;
12473  int res1 = SWIG_TMPOBJ ;
12474  int res2 ;
12475  char *buf2 = 0 ;
12476  int alloc2 = 0 ;
12477  int res3 ;
12478  char *buf3 = 0 ;
12479  int alloc3 = 0 ;
12480  double val4 ;
12481  int ecode4 = 0 ;
12482  double val5 ;
12483  int ecode5 = 0 ;
12484  double val6 ;
12485  int ecode6 = 0 ;
12486  double val7 ;
12487  int ecode7 = 0 ;
12488  double val8 ;
12489  int ecode8 = 0 ;
12490  double val9 ;
12491  int ecode9 = 0 ;
12492  double val10 ;
12493  int ecode10 = 0 ;
12494  int val11 ;
12495  int ecode11 = 0 ;
12496  int val12 ;
12497  int ecode12 = 0 ;
12498  int val13 ;
12499  int ecode13 = 0 ;
12500  int val14 ;
12501  int ecode14 = 0 ;
12502  PyArrayObject *tmp15 = NULL ;
12503  PyArrayObject *tmp16 = NULL ;
12504  char **tmp17 = NULL ;
12505  int res18 ;
12506  char *buf18 = 0 ;
12507  int alloc18 = 0 ;
12508  int res19 ;
12509  char *buf19 = 0 ;
12510  int alloc19 = 0 ;
12511  int res20 ;
12512  char *buf20 = 0 ;
12513  int alloc20 = 0 ;
12514  PyObject *swig_obj[19] ;
12515 
12516  arg1 = &temp1;
12517  if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
12518  res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
12519  if (!SWIG_IsOK(res2)) {
12520  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12521  }
12522  arg2 = (char *)(buf2);
12523  res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
12524  if (!SWIG_IsOK(res3)) {
12525  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12526  }
12527  arg3 = (char *)(buf3);
12528  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
12529  if (!SWIG_IsOK(ecode4)) {
12530  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12531  }
12532  arg4 = (PLFLT)(val4);
12533  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
12534  if (!SWIG_IsOK(ecode5)) {
12535  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12536  }
12537  arg5 = (PLFLT)(val5);
12538  ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
12539  if (!SWIG_IsOK(ecode6)) {
12540  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12541  }
12542  arg6 = (PLFLT)(val6);
12543  ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
12544  if (!SWIG_IsOK(ecode7)) {
12545  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12546  }
12547  arg7 = (PLFLT)(val7);
12548  ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
12549  if (!SWIG_IsOK(ecode8)) {
12550  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12551  }
12552  arg8 = (PLFLT)(val8);
12553  ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
12554  if (!SWIG_IsOK(ecode9)) {
12555  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12556  }
12557  arg9 = (PLFLT)(val9);
12558  ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
12559  if (!SWIG_IsOK(ecode10)) {
12560  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12561  }
12562  arg10 = (PLFLT)(val10);
12563  ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
12564  if (!SWIG_IsOK(ecode11)) {
12565  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12566  }
12567  arg11 = (PLBOOL)(val11);
12568  ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
12569  if (!SWIG_IsOK(ecode12)) {
12570  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12571  }
12572  arg12 = (PLBOOL)(val12);
12573  ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
12574  if (!SWIG_IsOK(ecode13)) {
12575  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12576  }
12577  arg13 = (PLINT)(val13);
12578  ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
12579  if (!SWIG_IsOK(ecode14)) {
12580  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12581  }
12582  arg14 = (PLINT)(val14);
12583  {
12584  tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
12585  if ( tmp15 == NULL )
12586  return NULL;
12587  Alen = PyArray_DIMS( tmp15 )[0];
12588  arg15 = (PLINT *) PyArray_DATA( tmp15 );
12589  }
12590  {
12591  tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
12592  if ( tmp16 == NULL )
12593  return NULL;
12594  if ( PyArray_DIMS( tmp16 )[0] != Alen )
12595  {
12596  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12597  return NULL;
12598  }
12599  arg16 = (PLINT *) PyArray_DATA( tmp16 );
12600  }
12601  {
12602  int i;
12603  PyObject *elt, *unicode_string;
12604 
12605  if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
12606  {
12607  PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12608  return NULL;
12609  }
12610  if ( Alen != 4 )
12611  {
12612  PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12613  return NULL;
12614  }
12615  tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
12616  if ( tmp17 == NULL )
12617  return NULL;
12618  arg17 = tmp17;
12619  for ( i = 0; i < 4; i++ )
12620  {
12621  arg17[i] = NULL;
12622  elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
12623  if ( PyString_Check( elt ) )
12624  {
12625  arg17[i] = PyString_AsString( elt );
12626  }
12627  else if ( PyUnicode_Check( elt ) )
12628  {
12629  unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
12630  arg17[i] = PyBytes_AS_STRING( unicode_string );
12631  }
12632  if ( arg17[i] == NULL )
12633  {
12634  free( tmp17 );
12635  return NULL;
12636  }
12637  }
12638  }
12639  res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
12640  if (!SWIG_IsOK(res18)) {
12641  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12642  }
12643  arg18 = (char *)(buf18);
12644  res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
12645  if (!SWIG_IsOK(res19)) {
12646  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12647  }
12648  arg19 = (char *)(buf19);
12649  res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
12650  if (!SWIG_IsOK(res20)) {
12651  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12652  }
12653  arg20 = (char *)(buf20);
12654  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);
12655  resultobj = SWIG_Py_Void();
12656  if (SWIG_IsTmpObj(res1)) {
12657  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12658  } else {
12659  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12660  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12661  }
12662  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12663  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12664  {
12665  Py_CLEAR( tmp15 );
12666  }
12667  {
12668  Py_CLEAR( tmp16 );
12669  }
12670  {
12671  free( tmp17 );
12672  }
12673  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12674  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12675  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12676  return resultobj;
12677 fail:
12678  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12679  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12680  {
12681  Py_CLEAR( tmp15 );
12682  }
12683  {
12684  Py_CLEAR( tmp16 );
12685  }
12686  {
12687  free( tmp17 );
12688  }
12689  if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12690  if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12691  if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12692  return NULL;
12693 }
12694 
12695 
12696 SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12697  PyObject *resultobj = 0;
12698  PLINT arg1 ;
12699  int val1 ;
12700  int ecode1 = 0 ;
12701  PyObject *swig_obj[1] ;
12702 
12703  if (!args) SWIG_fail;
12704  swig_obj[0] = args;
12705  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12706  if (!SWIG_IsOK(ecode1)) {
12707  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12708  }
12709  arg1 = (PLINT)(val1);
12710  plstripd(arg1);
12711  resultobj = SWIG_Py_Void();
12712  return resultobj;
12713 fail:
12714  return NULL;
12715 }
12716 
12717 
12718 SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12719  PyObject *resultobj = 0;
12720  PLINT arg1 ;
12721  PLINT *arg2 = (PLINT *) 0 ;
12722  PLINT *arg3 = (PLINT *) 0 ;
12723  PyArrayObject *tmp1 = NULL ;
12724  PyArrayObject *tmp3 = NULL ;
12725  PyObject *swig_obj[2] ;
12726 
12727  if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
12728  {
12729  tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
12730  if ( tmp1 == NULL )
12731  return NULL;
12732  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12733  arg2 = (PLINT *) PyArray_DATA( tmp1 );
12734  }
12735  {
12736  tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
12737  if ( tmp3 == NULL )
12738  return NULL;
12739  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12740  {
12741  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12742  return NULL;
12743  }
12744  arg3 = (PLINT *) PyArray_DATA( tmp3 );
12745  }
12746  plstyl(arg1,(int const *)arg2,(int const *)arg3);
12747  resultobj = SWIG_Py_Void();
12748  {
12749  Py_CLEAR( tmp1 );
12750  }
12751  {
12752  Py_CLEAR( tmp3 );
12753  }
12754  return resultobj;
12755 fail:
12756  {
12757  Py_CLEAR( tmp1 );
12758  }
12759  {
12760  Py_CLEAR( tmp3 );
12761  }
12762  return NULL;
12763 }
12764 
12765 
12766 SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767  PyObject *resultobj = 0;
12768  PLFLT *arg1 = (PLFLT *) 0 ;
12769  PLFLT *arg2 = (PLFLT *) 0 ;
12770  PLINT arg3 ;
12771  PLBOOL arg4 ;
12772  PyArrayObject *tmp1 = NULL ;
12773  PyArrayObject *tmp2 = NULL ;
12774  int val4 ;
12775  int ecode4 = 0 ;
12776  PyObject *swig_obj[3] ;
12777 
12778  if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
12779  {
12780  if ( swig_obj[0] != Py_None )
12781  {
12782  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12783  if ( tmp1 == NULL )
12784  return NULL;
12785  Alen = PyArray_DIMS( tmp1 )[0];
12786  arg1 = (PLFLT *) PyArray_DATA( tmp1 );
12787  }
12788  else
12789  {
12790  arg1 = NULL;
12791  Alen = 0;
12792  }
12793  }
12794  {
12795  if ( swig_obj[1] != Py_None )
12796  {
12797  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12798  if ( tmp2 == NULL )
12799  return NULL;
12800  if ( PyArray_DIMS( tmp2 )[0] != Alen )
12801  {
12802  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12803  return NULL;
12804  }
12805  arg2 = (PLFLT *) PyArray_DATA( tmp2 );
12806  arg3 = PyArray_DIMS( tmp2 )[0];
12807  }
12808  else
12809  {
12810  arg2 = NULL;
12811  arg3 = 0;
12812  }
12813  }
12814  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
12815  if (!SWIG_IsOK(ecode4)) {
12816  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12817  }
12818  arg4 = (PLBOOL)(val4);
12819  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12820  resultobj = SWIG_Py_Void();
12821  {
12822  Py_CLEAR( tmp1 );
12823  }
12824  {
12825  Py_CLEAR( tmp2 );
12826  }
12827  return resultobj;
12828 fail:
12829  {
12830  Py_CLEAR( tmp1 );
12831  }
12832  {
12833  Py_CLEAR( tmp2 );
12834  }
12835  return NULL;
12836 }
12837 
12838 
12839 SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840  PyObject *resultobj = 0;
12841  PLFLT arg1 ;
12842  PLFLT arg2 ;
12843  PLFLT arg3 ;
12844  PLFLT arg4 ;
12845  double val1 ;
12846  int ecode1 = 0 ;
12847  double val2 ;
12848  int ecode2 = 0 ;
12849  double val3 ;
12850  int ecode3 = 0 ;
12851  double val4 ;
12852  int ecode4 = 0 ;
12853  PyObject *swig_obj[4] ;
12854 
12855  if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
12856  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12857  if (!SWIG_IsOK(ecode1)) {
12858  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12859  }
12860  arg1 = (PLFLT)(val1);
12861  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12862  if (!SWIG_IsOK(ecode2)) {
12863  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12864  }
12865  arg2 = (PLFLT)(val2);
12866  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12867  if (!SWIG_IsOK(ecode3)) {
12868  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12869  }
12870  arg3 = (PLFLT)(val3);
12871  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12872  if (!SWIG_IsOK(ecode4)) {
12873  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12874  }
12875  arg4 = (PLFLT)(val4);
12876  plsvpa(arg1,arg2,arg3,arg4);
12877  resultobj = SWIG_Py_Void();
12878  return resultobj;
12879 fail:
12880  return NULL;
12881 }
12882 
12883 
12884 SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12885  PyObject *resultobj = 0;
12886  PLINT arg1 ;
12887  PLINT arg2 ;
12888  int val1 ;
12889  int ecode1 = 0 ;
12890  int val2 ;
12891  int ecode2 = 0 ;
12892  PyObject *swig_obj[2] ;
12893 
12894  if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
12895  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12896  if (!SWIG_IsOK(ecode1)) {
12897  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12898  }
12899  arg1 = (PLINT)(val1);
12900  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12901  if (!SWIG_IsOK(ecode2)) {
12902  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12903  }
12904  arg2 = (PLINT)(val2);
12905  plsxax(arg1,arg2);
12906  resultobj = SWIG_Py_Void();
12907  return resultobj;
12908 fail:
12909  return NULL;
12910 }
12911 
12912 
12913 SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914  PyObject *resultobj = 0;
12915  PLINT arg1 ;
12916  PLINT arg2 ;
12917  int val1 ;
12918  int ecode1 = 0 ;
12919  int val2 ;
12920  int ecode2 = 0 ;
12921  PyObject *swig_obj[2] ;
12922 
12923  if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
12924  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12925  if (!SWIG_IsOK(ecode1)) {
12926  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12927  }
12928  arg1 = (PLINT)(val1);
12929  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12930  if (!SWIG_IsOK(ecode2)) {
12931  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12932  }
12933  arg2 = (PLINT)(val2);
12934  plsyax(arg1,arg2);
12935  resultobj = SWIG_Py_Void();
12936  return resultobj;
12937 fail:
12938  return NULL;
12939 }
12940 
12941 
12942 SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943  PyObject *resultobj = 0;
12944  PLINT arg1 ;
12945  PLFLT *arg2 = (PLFLT *) 0 ;
12946  PLFLT *arg3 = (PLFLT *) 0 ;
12947  PLINT arg4 ;
12948  PyArrayObject *tmp1 = NULL ;
12949  PyArrayObject *tmp3 = NULL ;
12950  int val4 ;
12951  int ecode4 = 0 ;
12952  PyObject *swig_obj[3] ;
12953 
12954  if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
12955  {
12956  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12957  if ( tmp1 == NULL )
12958  return NULL;
12959  arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12960  arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12961  }
12962  {
12963  tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12964  if ( tmp3 == NULL )
12965  return NULL;
12966  if ( PyArray_DIMS( tmp3 )[0] != Alen )
12967  {
12968  PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12969  return NULL;
12970  }
12971  arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12972  }
12973  ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
12974  if (!SWIG_IsOK(ecode4)) {
12975  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
12976  }
12977  arg4 = (PLINT)(val4);
12978  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
12979  resultobj = SWIG_Py_Void();
12980  {
12981  Py_CLEAR( tmp1 );
12982  }
12983  {
12984  Py_CLEAR( tmp3 );
12985  }
12986  return resultobj;
12987 fail:
12988  {
12989  Py_CLEAR( tmp1 );
12990  }
12991  {
12992  Py_CLEAR( tmp3 );
12993  }
12994  return NULL;
12995 }
12996 
12997 
12998 SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999  PyObject *resultobj = 0;
13000  PLINT arg1 ;
13001  PLINT arg2 ;
13002  int val1 ;
13003  int ecode1 = 0 ;
13004  int val2 ;
13005  int ecode2 = 0 ;
13006  PyObject *swig_obj[2] ;
13007 
13008  if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13009  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13010  if (!SWIG_IsOK(ecode1)) {
13011  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13012  }
13013  arg1 = (PLINT)(val1);
13014  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13015  if (!SWIG_IsOK(ecode2)) {
13016  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13017  }
13018  arg2 = (PLINT)(val2);
13019  plszax(arg1,arg2);
13020  resultobj = SWIG_Py_Void();
13021  return resultobj;
13022 fail:
13023  return NULL;
13024 }
13025 
13026 
13027 SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13028  PyObject *resultobj = 0;
13029 
13030  if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13031  pltext();
13032  resultobj = SWIG_Py_Void();
13033  return resultobj;
13034 fail:
13035  return NULL;
13036 }
13037 
13038 
13039 SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13040  PyObject *resultobj = 0;
13041  char *arg1 = (char *) 0 ;
13042  int res1 ;
13043  char *buf1 = 0 ;
13044  int alloc1 = 0 ;
13045  PyObject *swig_obj[1] ;
13046 
13047  if (!args) SWIG_fail;
13048  swig_obj[0] = args;
13049  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13050  if (!SWIG_IsOK(res1)) {
13051  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13052  }
13053  arg1 = (char *)(buf1);
13054  pltimefmt((char const *)arg1);
13055  resultobj = SWIG_Py_Void();
13056  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13057  return resultobj;
13058 fail:
13059  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13060  return NULL;
13061 }
13062 
13063 
13064 SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13065  PyObject *resultobj = 0;
13066  PLFLT arg1 ;
13067  double val1 ;
13068  int ecode1 = 0 ;
13069  PyObject *swig_obj[1] ;
13070 
13071  if (!args) SWIG_fail;
13072  swig_obj[0] = args;
13073  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13074  if (!SWIG_IsOK(ecode1)) {
13075  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13076  }
13077  arg1 = (PLFLT)(val1);
13078  plvasp(arg1);
13079  resultobj = SWIG_Py_Void();
13080  return resultobj;
13081 fail:
13082  return NULL;
13083 }
13084 
13085 
13086 SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13087  PyObject *resultobj = 0;
13088  PLFLT **arg1 = (PLFLT **) 0 ;
13089  PLFLT **arg2 = (PLFLT **) 0 ;
13090  PLINT arg3 ;
13091  PLINT arg4 ;
13092  PLFLT arg5 ;
13093  pltr_func arg6 = (pltr_func) 0 ;
13094  PLPointer arg7 = (PLPointer) 0 ;
13095  PyArrayObject *tmp1 = NULL ;
13096  PyArrayObject *tmp2 = NULL ;
13097  double val5 ;
13098  int ecode5 = 0 ;
13099  PyObject *swig_obj[5] ;
13100 
13101  {
13102  python_pltr = 0;
13103  arg6 = NULL;
13104  }
13105  {
13106  arg7 = NULL;
13107  }
13108  if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13109  {
13110  int i, size;
13111  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13112  if ( tmp1 == NULL )
13113  return NULL;
13114  Xlen = PyArray_DIMS( tmp1 )[0];
13115  Ylen = PyArray_DIMS( tmp1 )[1];
13116  size = Ylen;
13117  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13118  for ( i = 0; i < Xlen; i++ )
13119  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13120  }
13121  {
13122  int i, size;
13123  tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13124  if ( tmp2 == NULL )
13125  return NULL;
13126  if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13127  {
13128  PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13129  return NULL;
13130  }
13131  arg3 = PyArray_DIMS( tmp2 )[0];
13132  arg4 = PyArray_DIMS( tmp2 )[1];
13133  size = arg4;
13134  arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13135  for ( i = 0; i < arg3; i++ )
13136  arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13137  }
13138  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13139  if (!SWIG_IsOK(ecode5)) {
13140  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13141  }
13142  arg5 = (PLFLT)(val5);
13143  if (swig_obj[3]) {
13144  {
13145  // it must be a callable or None
13146  if ( swig_obj[3] == Py_None )
13147  {
13148  arg6 = NULL;
13149  }
13150  else
13151  {
13152  if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13153  {
13154  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13155  return NULL;
13156  }
13157  arg6 = marshal_pltr( swig_obj[3] );
13158  }
13159  }
13160  }
13161  if (swig_obj[4]) {
13162  {
13163  if ( swig_obj[4] == Py_None )
13164  arg7 = NULL;
13165  else
13166  {
13167  arg7 = marshal_PLPointer( swig_obj[4], 0 );
13168  }
13169  }
13170  }
13171  plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13172  resultobj = SWIG_Py_Void();
13173  {
13174  Py_CLEAR( tmp1 );
13175  free( arg1 );
13176  }
13177  {
13178  Py_CLEAR( tmp2 );
13179  free( arg2 );
13180  }
13181  {
13182  cleanup_pltr();
13183  }
13184  {
13186  }
13187  return resultobj;
13188 fail:
13189  {
13190  Py_CLEAR( tmp1 );
13191  free( arg1 );
13192  }
13193  {
13194  Py_CLEAR( tmp2 );
13195  free( arg2 );
13196  }
13197  {
13198  cleanup_pltr();
13199  }
13200  {
13202  }
13203  return NULL;
13204 }
13205 
13206 
13207 SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13208  PyObject *resultobj = 0;
13209  PLFLT arg1 ;
13210  PLFLT arg2 ;
13211  PLFLT arg3 ;
13212  PLFLT arg4 ;
13213  PLFLT arg5 ;
13214  double val1 ;
13215  int ecode1 = 0 ;
13216  double val2 ;
13217  int ecode2 = 0 ;
13218  double val3 ;
13219  int ecode3 = 0 ;
13220  double val4 ;
13221  int ecode4 = 0 ;
13222  double val5 ;
13223  int ecode5 = 0 ;
13224  PyObject *swig_obj[5] ;
13225 
13226  if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13227  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13228  if (!SWIG_IsOK(ecode1)) {
13229  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13230  }
13231  arg1 = (PLFLT)(val1);
13232  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13233  if (!SWIG_IsOK(ecode2)) {
13234  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13235  }
13236  arg2 = (PLFLT)(val2);
13237  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13238  if (!SWIG_IsOK(ecode3)) {
13239  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13240  }
13241  arg3 = (PLFLT)(val3);
13242  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13243  if (!SWIG_IsOK(ecode4)) {
13244  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13245  }
13246  arg4 = (PLFLT)(val4);
13247  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13248  if (!SWIG_IsOK(ecode5)) {
13249  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13250  }
13251  arg5 = (PLFLT)(val5);
13252  plvpas(arg1,arg2,arg3,arg4,arg5);
13253  resultobj = SWIG_Py_Void();
13254  return resultobj;
13255 fail:
13256  return NULL;
13257 }
13258 
13259 
13260 SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13261  PyObject *resultobj = 0;
13262  PLFLT arg1 ;
13263  PLFLT arg2 ;
13264  PLFLT arg3 ;
13265  PLFLT arg4 ;
13266  double val1 ;
13267  int ecode1 = 0 ;
13268  double val2 ;
13269  int ecode2 = 0 ;
13270  double val3 ;
13271  int ecode3 = 0 ;
13272  double val4 ;
13273  int ecode4 = 0 ;
13274  PyObject *swig_obj[4] ;
13275 
13276  if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
13277  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13278  if (!SWIG_IsOK(ecode1)) {
13279  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13280  }
13281  arg1 = (PLFLT)(val1);
13282  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13283  if (!SWIG_IsOK(ecode2)) {
13284  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13285  }
13286  arg2 = (PLFLT)(val2);
13287  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13288  if (!SWIG_IsOK(ecode3)) {
13289  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13290  }
13291  arg3 = (PLFLT)(val3);
13292  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13293  if (!SWIG_IsOK(ecode4)) {
13294  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13295  }
13296  arg4 = (PLFLT)(val4);
13297  plvpor(arg1,arg2,arg3,arg4);
13298  resultobj = SWIG_Py_Void();
13299  return resultobj;
13300 fail:
13301  return NULL;
13302 }
13303 
13304 
13305 SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306  PyObject *resultobj = 0;
13307 
13308  if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
13309  plvsta();
13310  resultobj = SWIG_Py_Void();
13311  return resultobj;
13312 fail:
13313  return NULL;
13314 }
13315 
13316 
13317 SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13318  PyObject *resultobj = 0;
13319  PLFLT arg1 ;
13320  PLFLT arg2 ;
13321  PLFLT arg3 ;
13322  PLFLT arg4 ;
13323  PLFLT arg5 ;
13324  PLFLT arg6 ;
13325  PLFLT arg7 ;
13326  PLFLT arg8 ;
13327  PLFLT arg9 ;
13328  PLFLT arg10 ;
13329  PLFLT arg11 ;
13330  double val1 ;
13331  int ecode1 = 0 ;
13332  double val2 ;
13333  int ecode2 = 0 ;
13334  double val3 ;
13335  int ecode3 = 0 ;
13336  double val4 ;
13337  int ecode4 = 0 ;
13338  double val5 ;
13339  int ecode5 = 0 ;
13340  double val6 ;
13341  int ecode6 = 0 ;
13342  double val7 ;
13343  int ecode7 = 0 ;
13344  double val8 ;
13345  int ecode8 = 0 ;
13346  double val9 ;
13347  int ecode9 = 0 ;
13348  double val10 ;
13349  int ecode10 = 0 ;
13350  double val11 ;
13351  int ecode11 = 0 ;
13352  PyObject *swig_obj[11] ;
13353 
13354  if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
13355  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13356  if (!SWIG_IsOK(ecode1)) {
13357  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13358  }
13359  arg1 = (PLFLT)(val1);
13360  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13361  if (!SWIG_IsOK(ecode2)) {
13362  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13363  }
13364  arg2 = (PLFLT)(val2);
13365  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13366  if (!SWIG_IsOK(ecode3)) {
13367  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13368  }
13369  arg3 = (PLFLT)(val3);
13370  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13371  if (!SWIG_IsOK(ecode4)) {
13372  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13373  }
13374  arg4 = (PLFLT)(val4);
13375  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13376  if (!SWIG_IsOK(ecode5)) {
13377  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13378  }
13379  arg5 = (PLFLT)(val5);
13380  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13381  if (!SWIG_IsOK(ecode6)) {
13382  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13383  }
13384  arg6 = (PLFLT)(val6);
13385  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13386  if (!SWIG_IsOK(ecode7)) {
13387  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13388  }
13389  arg7 = (PLFLT)(val7);
13390  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13391  if (!SWIG_IsOK(ecode8)) {
13392  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13393  }
13394  arg8 = (PLFLT)(val8);
13395  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13396  if (!SWIG_IsOK(ecode9)) {
13397  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13398  }
13399  arg9 = (PLFLT)(val9);
13400  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13401  if (!SWIG_IsOK(ecode10)) {
13402  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13403  }
13404  arg10 = (PLFLT)(val10);
13405  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
13406  if (!SWIG_IsOK(ecode11)) {
13407  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13408  }
13409  arg11 = (PLFLT)(val11);
13410  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13411  resultobj = SWIG_Py_Void();
13412  return resultobj;
13413 fail:
13414  return NULL;
13415 }
13416 
13417 
13418 SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13419  PyObject *resultobj = 0;
13420  PLFLT arg1 ;
13421  double val1 ;
13422  int ecode1 = 0 ;
13423  PyObject *swig_obj[1] ;
13424 
13425  if (!args) SWIG_fail;
13426  swig_obj[0] = args;
13427  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13428  if (!SWIG_IsOK(ecode1)) {
13429  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13430  }
13431  arg1 = (PLFLT)(val1);
13432  plwidth(arg1);
13433  resultobj = SWIG_Py_Void();
13434  return resultobj;
13435 fail:
13436  return NULL;
13437 }
13438 
13439 
13440 SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13441  PyObject *resultobj = 0;
13442  PLFLT arg1 ;
13443  PLFLT arg2 ;
13444  PLFLT arg3 ;
13445  PLFLT arg4 ;
13446  double val1 ;
13447  int ecode1 = 0 ;
13448  double val2 ;
13449  int ecode2 = 0 ;
13450  double val3 ;
13451  int ecode3 = 0 ;
13452  double val4 ;
13453  int ecode4 = 0 ;
13454  PyObject *swig_obj[4] ;
13455 
13456  if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
13457  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13458  if (!SWIG_IsOK(ecode1)) {
13459  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13460  }
13461  arg1 = (PLFLT)(val1);
13462  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13463  if (!SWIG_IsOK(ecode2)) {
13464  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13465  }
13466  arg2 = (PLFLT)(val2);
13467  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13468  if (!SWIG_IsOK(ecode3)) {
13469  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13470  }
13471  arg3 = (PLFLT)(val3);
13472  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13473  if (!SWIG_IsOK(ecode4)) {
13474  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13475  }
13476  arg4 = (PLFLT)(val4);
13477  plwind(arg1,arg2,arg3,arg4);
13478  resultobj = SWIG_Py_Void();
13479  return resultobj;
13480 fail:
13481  return NULL;
13482 }
13483 
13484 
13485 SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13486  PyObject *resultobj = 0;
13487  PLBOOL arg1 ;
13488  PLBOOL *arg2 = (PLBOOL *) 0 ;
13489  int val1 ;
13490  int ecode1 = 0 ;
13491  PLBOOL temp2 ;
13492  int res2 = SWIG_TMPOBJ ;
13493  PyObject *swig_obj[1] ;
13494 
13495  arg2 = &temp2;
13496  if (!args) SWIG_fail;
13497  swig_obj[0] = args;
13498  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13499  if (!SWIG_IsOK(ecode1)) {
13500  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13501  }
13502  arg1 = (PLBOOL)(val1);
13503  plxormod(arg1,arg2);
13504  resultobj = SWIG_Py_Void();
13505  if (SWIG_IsTmpObj(res2)) {
13506  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13507  } else {
13508  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13509  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13510  }
13511  return resultobj;
13512 fail:
13513  return NULL;
13514 }
13515 
13516 
13517 SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13518  PyObject *resultobj = 0;
13519  mapform_func arg1 = (mapform_func) 0 ;
13520  char *arg2 = (char *) 0 ;
13521  PLFLT arg3 ;
13522  PLFLT arg4 ;
13523  PLFLT arg5 ;
13524  PLFLT arg6 ;
13525  int res2 ;
13526  char *buf2 = 0 ;
13527  int alloc2 = 0 ;
13528  double val3 ;
13529  int ecode3 = 0 ;
13530  double val4 ;
13531  int ecode4 = 0 ;
13532  double val5 ;
13533  int ecode5 = 0 ;
13534  double val6 ;
13535  int ecode6 = 0 ;
13536  PyObject *swig_obj[6] ;
13537 
13538  if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
13539  {
13540  // it must be a callable or none
13541  if ( swig_obj[0] == Py_None )
13542  {
13543  arg1 = NULL;
13544  }
13545  else
13546  {
13547  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13548  {
13549  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13550  return NULL;
13551  }
13552  arg1 = marshal_mapform( swig_obj[0] );
13553  }
13554  }
13555  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13556  if (!SWIG_IsOK(res2)) {
13557  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13558  }
13559  arg2 = (char *)(buf2);
13560  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13561  if (!SWIG_IsOK(ecode3)) {
13562  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13563  }
13564  arg3 = (PLFLT)(val3);
13565  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13566  if (!SWIG_IsOK(ecode4)) {
13567  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13568  }
13569  arg4 = (PLFLT)(val4);
13570  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13571  if (!SWIG_IsOK(ecode5)) {
13572  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13573  }
13574  arg5 = (PLFLT)(val5);
13575  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13576  if (!SWIG_IsOK(ecode6)) {
13577  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13578  }
13579  arg6 = (PLFLT)(val6);
13580  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13581  resultobj = SWIG_Py_Void();
13582  {
13583  cleanup_mapform();
13584  }
13585  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13586  return resultobj;
13587 fail:
13588  {
13589  cleanup_mapform();
13590  }
13591  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13592  return NULL;
13593 }
13594 
13595 
13596 SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13597  PyObject *resultobj = 0;
13598  mapform_func arg1 = (mapform_func) 0 ;
13599  char *arg2 = (char *) 0 ;
13600  PLFLT arg3 ;
13601  PLFLT arg4 ;
13602  PLFLT arg5 ;
13603  PLFLT arg6 ;
13604  PLINT *arg7 = (PLINT *) 0 ;
13605  PLINT arg8 ;
13606  int res2 ;
13607  char *buf2 = 0 ;
13608  int alloc2 = 0 ;
13609  double val3 ;
13610  int ecode3 = 0 ;
13611  double val4 ;
13612  int ecode4 = 0 ;
13613  double val5 ;
13614  int ecode5 = 0 ;
13615  double val6 ;
13616  int ecode6 = 0 ;
13617  PyArrayObject *tmp7 = NULL ;
13618  PyObject *swig_obj[7] ;
13619 
13620  if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
13621  {
13622  // it must be a callable or none
13623  if ( swig_obj[0] == Py_None )
13624  {
13625  arg1 = NULL;
13626  }
13627  else
13628  {
13629  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13630  {
13631  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13632  return NULL;
13633  }
13634  arg1 = marshal_mapform( swig_obj[0] );
13635  }
13636  }
13637  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13638  if (!SWIG_IsOK(res2)) {
13639  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
13640  }
13641  arg2 = (char *)(buf2);
13642  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13643  if (!SWIG_IsOK(ecode3)) {
13644  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
13645  }
13646  arg3 = (PLFLT)(val3);
13647  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13648  if (!SWIG_IsOK(ecode4)) {
13649  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
13650  }
13651  arg4 = (PLFLT)(val4);
13652  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13653  if (!SWIG_IsOK(ecode5)) {
13654  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
13655  }
13656  arg5 = (PLFLT)(val5);
13657  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13658  if (!SWIG_IsOK(ecode6)) {
13659  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
13660  }
13661  arg6 = (PLFLT)(val6);
13662  {
13663  if ( swig_obj[6] != Py_None )
13664  {
13665  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
13666  if ( tmp7 == NULL )
13667  return NULL;
13668  arg7 = (PLINT *) PyArray_DATA( tmp7 );
13669  arg8 = PyArray_DIMS( tmp7 )[0];
13670  }
13671  else
13672  {
13673  arg7 = NULL;
13674  arg8 = 0;
13675  }
13676  }
13677  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
13678  resultobj = SWIG_Py_Void();
13679  {
13680  cleanup_mapform();
13681  }
13682  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13683  {
13684  Py_CLEAR( tmp7 );
13685  }
13686  return resultobj;
13687 fail:
13688  {
13689  cleanup_mapform();
13690  }
13691  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13692  {
13693  Py_CLEAR( tmp7 );
13694  }
13695  return NULL;
13696 }
13697 
13698 
13699 SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13700  PyObject *resultobj = 0;
13701  mapform_func arg1 = (mapform_func) 0 ;
13702  char *arg2 = (char *) 0 ;
13703  char *arg3 = (char *) 0 ;
13704  PLFLT arg4 ;
13705  PLFLT arg5 ;
13706  PLFLT arg6 ;
13707  PLFLT arg7 ;
13708  PLINT *arg8 = (PLINT *) 0 ;
13709  PLINT arg9 ;
13710  int res2 ;
13711  char *buf2 = 0 ;
13712  int alloc2 = 0 ;
13713  int res3 ;
13714  char *buf3 = 0 ;
13715  int alloc3 = 0 ;
13716  double val4 ;
13717  int ecode4 = 0 ;
13718  double val5 ;
13719  int ecode5 = 0 ;
13720  double val6 ;
13721  int ecode6 = 0 ;
13722  double val7 ;
13723  int ecode7 = 0 ;
13724  PyArrayObject *tmp8 = NULL ;
13725  PyObject *swig_obj[8] ;
13726 
13727  if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
13728  {
13729  // it must be a callable or none
13730  if ( swig_obj[0] == Py_None )
13731  {
13732  arg1 = NULL;
13733  }
13734  else
13735  {
13736  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13737  {
13738  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13739  return NULL;
13740  }
13741  arg1 = marshal_mapform( swig_obj[0] );
13742  }
13743  }
13744  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13745  if (!SWIG_IsOK(res2)) {
13746  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
13747  }
13748  arg2 = (char *)(buf2);
13749  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
13750  if (!SWIG_IsOK(res3)) {
13751  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
13752  }
13753  arg3 = (char *)(buf3);
13754  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13755  if (!SWIG_IsOK(ecode4)) {
13756  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
13757  }
13758  arg4 = (PLFLT)(val4);
13759  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13760  if (!SWIG_IsOK(ecode5)) {
13761  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
13762  }
13763  arg5 = (PLFLT)(val5);
13764  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13765  if (!SWIG_IsOK(ecode6)) {
13766  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
13767  }
13768  arg6 = (PLFLT)(val6);
13769  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13770  if (!SWIG_IsOK(ecode7)) {
13771  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
13772  }
13773  arg7 = (PLFLT)(val7);
13774  {
13775  if ( swig_obj[7] != Py_None )
13776  {
13777  tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
13778  if ( tmp8 == NULL )
13779  return NULL;
13780  arg8 = (PLINT *) PyArray_DATA( tmp8 );
13781  arg9 = PyArray_DIMS( tmp8 )[0];
13782  }
13783  else
13784  {
13785  arg8 = NULL;
13786  arg9 = 0;
13787  }
13788  }
13789  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
13790  resultobj = SWIG_Py_Void();
13791  {
13792  cleanup_mapform();
13793  }
13794  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13795  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13796  {
13797  Py_CLEAR( tmp8 );
13798  }
13799  return resultobj;
13800 fail:
13801  {
13802  cleanup_mapform();
13803  }
13804  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13805  if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13806  {
13807  Py_CLEAR( tmp8 );
13808  }
13809  return NULL;
13810 }
13811 
13812 
13813 SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13814  PyObject *resultobj = 0;
13815  mapform_func arg1 = (mapform_func) 0 ;
13816  char *arg2 = (char *) 0 ;
13817  PLFLT arg3 ;
13818  PLFLT arg4 ;
13819  PLFLT arg5 ;
13820  char *arg6 = (char *) 0 ;
13821  PLFLT arg7 ;
13822  PLFLT arg8 ;
13823  PLFLT arg9 ;
13824  PLFLT arg10 ;
13825  PLINT arg11 ;
13826  int res2 ;
13827  char *buf2 = 0 ;
13828  int alloc2 = 0 ;
13829  double val3 ;
13830  int ecode3 = 0 ;
13831  double val4 ;
13832  int ecode4 = 0 ;
13833  double val5 ;
13834  int ecode5 = 0 ;
13835  int res6 ;
13836  char *buf6 = 0 ;
13837  int alloc6 = 0 ;
13838  double val7 ;
13839  int ecode7 = 0 ;
13840  double val8 ;
13841  int ecode8 = 0 ;
13842  double val9 ;
13843  int ecode9 = 0 ;
13844  double val10 ;
13845  int ecode10 = 0 ;
13846  int val11 ;
13847  int ecode11 = 0 ;
13848  PyObject *swig_obj[11] ;
13849 
13850  if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
13851  {
13852  // it must be a callable or none
13853  if ( swig_obj[0] == Py_None )
13854  {
13855  arg1 = NULL;
13856  }
13857  else
13858  {
13859  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13860  {
13861  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13862  return NULL;
13863  }
13864  arg1 = marshal_mapform( swig_obj[0] );
13865  }
13866  }
13867  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13868  if (!SWIG_IsOK(res2)) {
13869  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
13870  }
13871  arg2 = (char *)(buf2);
13872  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13873  if (!SWIG_IsOK(ecode3)) {
13874  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
13875  }
13876  arg3 = (PLFLT)(val3);
13877  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13878  if (!SWIG_IsOK(ecode4)) {
13879  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
13880  }
13881  arg4 = (PLFLT)(val4);
13882  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13883  if (!SWIG_IsOK(ecode5)) {
13884  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
13885  }
13886  arg5 = (PLFLT)(val5);
13887  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
13888  if (!SWIG_IsOK(res6)) {
13889  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
13890  }
13891  arg6 = (char *)(buf6);
13892  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13893  if (!SWIG_IsOK(ecode7)) {
13894  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
13895  }
13896  arg7 = (PLFLT)(val7);
13897  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13898  if (!SWIG_IsOK(ecode8)) {
13899  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
13900  }
13901  arg8 = (PLFLT)(val8);
13902  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13903  if (!SWIG_IsOK(ecode9)) {
13904  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
13905  }
13906  arg9 = (PLFLT)(val9);
13907  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13908  if (!SWIG_IsOK(ecode10)) {
13909  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
13910  }
13911  arg10 = (PLFLT)(val10);
13912  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
13913  if (!SWIG_IsOK(ecode11)) {
13914  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
13915  }
13916  arg11 = (PLINT)(val11);
13917  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
13918  resultobj = SWIG_Py_Void();
13919  {
13920  cleanup_mapform();
13921  }
13922  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13923  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13924  return resultobj;
13925 fail:
13926  {
13927  cleanup_mapform();
13928  }
13929  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13930  if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13931  return NULL;
13932 }
13933 
13934 
13935 SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13936  PyObject *resultobj = 0;
13937  mapform_func arg1 = (mapform_func) 0 ;
13938  char *arg2 = (char *) 0 ;
13939  PLFLT arg3 ;
13940  PLFLT arg4 ;
13941  PLFLT arg5 ;
13942  PLFLT arg6 ;
13943  PLINT *arg7 = (PLINT *) 0 ;
13944  PLINT arg8 ;
13945  int res2 ;
13946  char *buf2 = 0 ;
13947  int alloc2 = 0 ;
13948  double val3 ;
13949  int ecode3 = 0 ;
13950  double val4 ;
13951  int ecode4 = 0 ;
13952  double val5 ;
13953  int ecode5 = 0 ;
13954  double val6 ;
13955  int ecode6 = 0 ;
13956  PyArrayObject *tmp7 = NULL ;
13957  PyObject *swig_obj[7] ;
13958 
13959  if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
13960  {
13961  // it must be a callable or none
13962  if ( swig_obj[0] == Py_None )
13963  {
13964  arg1 = NULL;
13965  }
13966  else
13967  {
13968  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13969  {
13970  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13971  return NULL;
13972  }
13973  arg1 = marshal_mapform( swig_obj[0] );
13974  }
13975  }
13976  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13977  if (!SWIG_IsOK(res2)) {
13978  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
13979  }
13980  arg2 = (char *)(buf2);
13981  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13982  if (!SWIG_IsOK(ecode3)) {
13983  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
13984  }
13985  arg3 = (PLFLT)(val3);
13986  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13987  if (!SWIG_IsOK(ecode4)) {
13988  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
13989  }
13990  arg4 = (PLFLT)(val4);
13991  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13992  if (!SWIG_IsOK(ecode5)) {
13993  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
13994  }
13995  arg5 = (PLFLT)(val5);
13996  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13997  if (!SWIG_IsOK(ecode6)) {
13998  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
13999  }
14000  arg6 = (PLFLT)(val6);
14001  {
14002  if ( swig_obj[6] != Py_None )
14003  {
14004  tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14005  if ( tmp7 == NULL )
14006  return NULL;
14007  arg7 = (PLINT *) PyArray_DATA( tmp7 );
14008  arg8 = PyArray_DIMS( tmp7 )[0];
14009  }
14010  else
14011  {
14012  arg7 = NULL;
14013  arg8 = 0;
14014  }
14015  }
14016  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14017  resultobj = SWIG_Py_Void();
14018  {
14019  cleanup_mapform();
14020  }
14021  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14022  {
14023  Py_CLEAR( tmp7 );
14024  }
14025  return resultobj;
14026 fail:
14027  {
14028  cleanup_mapform();
14029  }
14030  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14031  {
14032  Py_CLEAR( tmp7 );
14033  }
14034  return NULL;
14035 }
14036 
14037 
14038 SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14039  PyObject *resultobj = 0;
14040  mapform_func arg1 = (mapform_func) 0 ;
14041  PLFLT arg2 ;
14042  PLFLT arg3 ;
14043  PLFLT arg4 ;
14044  PLFLT arg5 ;
14045  PLFLT arg6 ;
14046  PLFLT arg7 ;
14047  double val2 ;
14048  int ecode2 = 0 ;
14049  double val3 ;
14050  int ecode3 = 0 ;
14051  double val4 ;
14052  int ecode4 = 0 ;
14053  double val5 ;
14054  int ecode5 = 0 ;
14055  double val6 ;
14056  int ecode6 = 0 ;
14057  double val7 ;
14058  int ecode7 = 0 ;
14059  PyObject *swig_obj[7] ;
14060 
14061  if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14062  {
14063  // it must be a callable or none
14064  if ( swig_obj[0] == Py_None )
14065  {
14066  arg1 = NULL;
14067  }
14068  else
14069  {
14070  if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14071  {
14072  PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14073  return NULL;
14074  }
14075  arg1 = marshal_mapform( swig_obj[0] );
14076  }
14077  }
14078  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14079  if (!SWIG_IsOK(ecode2)) {
14080  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14081  }
14082  arg2 = (PLFLT)(val2);
14083  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14084  if (!SWIG_IsOK(ecode3)) {
14085  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14086  }
14087  arg3 = (PLFLT)(val3);
14088  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14089  if (!SWIG_IsOK(ecode4)) {
14090  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14091  }
14092  arg4 = (PLFLT)(val4);
14093  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14094  if (!SWIG_IsOK(ecode5)) {
14095  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14096  }
14097  arg5 = (PLFLT)(val5);
14098  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14099  if (!SWIG_IsOK(ecode6)) {
14100  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14101  }
14102  arg6 = (PLFLT)(val6);
14103  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14104  if (!SWIG_IsOK(ecode7)) {
14105  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14106  }
14107  arg7 = (PLFLT)(val7);
14108  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14109  resultobj = SWIG_Py_Void();
14110  {
14111  cleanup_mapform();
14112  }
14113  return resultobj;
14114 fail:
14115  {
14116  cleanup_mapform();
14117  }
14118  return NULL;
14119 }
14120 
14121 
14122 SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14123  PyObject *resultobj = 0;
14124  PLFLT **arg1 = (PLFLT **) 0 ;
14125  PLINT arg2 ;
14126  PLINT arg3 ;
14127  PLFLT arg4 ;
14128  PLFLT arg5 ;
14129  PLFLT arg6 ;
14130  PLFLT arg7 ;
14131  PLFLT arg8 ;
14132  PLFLT arg9 ;
14133  PLFLT arg10 ;
14134  PLFLT arg11 ;
14135  PLFLT arg12 ;
14136  PLFLT arg13 ;
14137  PyArrayObject *tmp1 = NULL ;
14138  double val4 ;
14139  int ecode4 = 0 ;
14140  double val5 ;
14141  int ecode5 = 0 ;
14142  double val6 ;
14143  int ecode6 = 0 ;
14144  double val7 ;
14145  int ecode7 = 0 ;
14146  double val8 ;
14147  int ecode8 = 0 ;
14148  double val9 ;
14149  int ecode9 = 0 ;
14150  double val10 ;
14151  int ecode10 = 0 ;
14152  double val11 ;
14153  int ecode11 = 0 ;
14154  double val12 ;
14155  int ecode12 = 0 ;
14156  double val13 ;
14157  int ecode13 = 0 ;
14158  PyObject *swig_obj[11] ;
14159 
14160  if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14161  {
14162  int i, size;
14163  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14164  if ( tmp1 == NULL )
14165  return NULL;
14166  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14167  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14168  size = arg3;
14169  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14170  for ( i = 0; i < arg2; i++ )
14171  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14172  }
14173  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14174  if (!SWIG_IsOK(ecode4)) {
14175  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14176  }
14177  arg4 = (PLFLT)(val4);
14178  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14179  if (!SWIG_IsOK(ecode5)) {
14180  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14181  }
14182  arg5 = (PLFLT)(val5);
14183  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14184  if (!SWIG_IsOK(ecode6)) {
14185  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14186  }
14187  arg6 = (PLFLT)(val6);
14188  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14189  if (!SWIG_IsOK(ecode7)) {
14190  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14191  }
14192  arg7 = (PLFLT)(val7);
14193  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14194  if (!SWIG_IsOK(ecode8)) {
14195  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14196  }
14197  arg8 = (PLFLT)(val8);
14198  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14199  if (!SWIG_IsOK(ecode9)) {
14200  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14201  }
14202  arg9 = (PLFLT)(val9);
14203  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14204  if (!SWIG_IsOK(ecode10)) {
14205  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14206  }
14207  arg10 = (PLFLT)(val10);
14208  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14209  if (!SWIG_IsOK(ecode11)) {
14210  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14211  }
14212  arg11 = (PLFLT)(val11);
14213  ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14214  if (!SWIG_IsOK(ecode12)) {
14215  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14216  }
14217  arg12 = (PLFLT)(val12);
14218  ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14219  if (!SWIG_IsOK(ecode13)) {
14220  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14221  }
14222  arg13 = (PLFLT)(val13);
14223  plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14224  resultobj = SWIG_Py_Void();
14225  {
14226  Py_CLEAR( tmp1 );
14227  free( arg1 );
14228  }
14229  return resultobj;
14230 fail:
14231  {
14232  Py_CLEAR( tmp1 );
14233  free( arg1 );
14234  }
14235  return NULL;
14236 }
14237 
14238 
14239 SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240  PyObject *resultobj = 0;
14241  PLFLT **arg1 = (PLFLT **) 0 ;
14242  PLINT arg2 ;
14243  PLINT arg3 ;
14244  PLFLT arg4 ;
14245  PLFLT arg5 ;
14246  PLFLT arg6 ;
14247  PLFLT arg7 ;
14248  PLFLT arg8 ;
14249  PLFLT arg9 ;
14250  PLFLT arg10 ;
14251  PLFLT arg11 ;
14252  pltr_func arg12 = (pltr_func) 0 ;
14253  PLPointer arg13 = (PLPointer) 0 ;
14254  PyArrayObject *tmp1 = NULL ;
14255  double val4 ;
14256  int ecode4 = 0 ;
14257  double val5 ;
14258  int ecode5 = 0 ;
14259  double val6 ;
14260  int ecode6 = 0 ;
14261  double val7 ;
14262  int ecode7 = 0 ;
14263  double val8 ;
14264  int ecode8 = 0 ;
14265  double val9 ;
14266  int ecode9 = 0 ;
14267  double val10 ;
14268  int ecode10 = 0 ;
14269  double val11 ;
14270  int ecode11 = 0 ;
14271  PyObject *swig_obj[11] ;
14272 
14273  {
14274  python_pltr = 0;
14275  arg12 = NULL;
14276  }
14277  {
14278  arg13 = NULL;
14279  }
14280  if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
14281  {
14282  int i, size;
14283  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14284  if ( tmp1 == NULL )
14285  return NULL;
14286  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14287  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14288  size = arg3;
14289  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14290  for ( i = 0; i < arg2; i++ )
14291  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14292  }
14293  ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14294  if (!SWIG_IsOK(ecode4)) {
14295  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14296  }
14297  arg4 = (PLFLT)(val4);
14298  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14299  if (!SWIG_IsOK(ecode5)) {
14300  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14301  }
14302  arg5 = (PLFLT)(val5);
14303  ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14304  if (!SWIG_IsOK(ecode6)) {
14305  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14306  }
14307  arg6 = (PLFLT)(val6);
14308  ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14309  if (!SWIG_IsOK(ecode7)) {
14310  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14311  }
14312  arg7 = (PLFLT)(val7);
14313  ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14314  if (!SWIG_IsOK(ecode8)) {
14315  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14316  }
14317  arg8 = (PLFLT)(val8);
14318  ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14319  if (!SWIG_IsOK(ecode9)) {
14320  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14321  }
14322  arg9 = (PLFLT)(val9);
14323  ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14324  if (!SWIG_IsOK(ecode10)) {
14325  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14326  }
14327  arg10 = (PLFLT)(val10);
14328  ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14329  if (!SWIG_IsOK(ecode11)) {
14330  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14331  }
14332  arg11 = (PLFLT)(val11);
14333  if (swig_obj[9]) {
14334  {
14335  // it must be a callable or None
14336  if ( swig_obj[9] == Py_None )
14337  {
14338  arg12 = NULL;
14339  }
14340  else
14341  {
14342  if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
14343  {
14344  PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14345  return NULL;
14346  }
14347  arg12 = marshal_pltr( swig_obj[9] );
14348  }
14349  }
14350  }
14351  if (swig_obj[10]) {
14352  {
14353  if ( swig_obj[10] == Py_None )
14354  arg13 = NULL;
14355  else
14356  {
14357  arg13 = marshal_PLPointer( swig_obj[10], 1 );
14358  }
14359  }
14360  }
14361  plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14362  resultobj = SWIG_Py_Void();
14363  {
14364  Py_CLEAR( tmp1 );
14365  free( arg1 );
14366  }
14367  {
14368  cleanup_pltr();
14369  }
14370  {
14372  }
14373  return resultobj;
14374 fail:
14375  {
14376  Py_CLEAR( tmp1 );
14377  free( arg1 );
14378  }
14379  {
14380  cleanup_pltr();
14381  }
14382  {
14384  }
14385  return NULL;
14386 }
14387 
14388 
14389 SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14390  PyObject *resultobj = 0;
14391 
14392  if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
14393  plClearOpts();
14394  resultobj = SWIG_Py_Void();
14395  return resultobj;
14396 fail:
14397  return NULL;
14398 }
14399 
14400 
14401 SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14402  PyObject *resultobj = 0;
14403 
14404  if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
14405  plResetOpts();
14406  resultobj = SWIG_Py_Void();
14407  return resultobj;
14408 fail:
14409  return NULL;
14410 }
14411 
14412 
14413 SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14414  PyObject *resultobj = 0;
14415  char *arg1 = (char *) 0 ;
14416  char *arg2 = (char *) 0 ;
14417  int res1 ;
14418  char *buf1 = 0 ;
14419  int alloc1 = 0 ;
14420  int res2 ;
14421  char *buf2 = 0 ;
14422  int alloc2 = 0 ;
14423  PyObject *swig_obj[2] ;
14424 
14425  if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
14426  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
14427  if (!SWIG_IsOK(res1)) {
14428  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14429  }
14430  arg1 = (char *)(buf1);
14431  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14432  if (!SWIG_IsOK(res2)) {
14433  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14434  }
14435  arg2 = (char *)(buf2);
14436  plSetUsage((char const *)arg1,(char const *)arg2);
14437  resultobj = SWIG_Py_Void();
14438  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14439  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14440  return resultobj;
14441 fail:
14442  if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14443  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14444  return NULL;
14445 }
14446 
14447 
14448 SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14449  PyObject *resultobj = 0;
14450 
14451  if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
14452  plOptUsage();
14453  resultobj = SWIG_Py_Void();
14454  return resultobj;
14455 fail:
14456  return NULL;
14457 }
14458 
14459 
14460 SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14461  PyObject *resultobj = 0;
14462  PLFLT **arg1 = (PLFLT **) 0 ;
14463  PLINT arg2 ;
14464  PLINT arg3 ;
14465  PLFLT *arg4 = (PLFLT *) 0 ;
14466  PLFLT *arg5 = (PLFLT *) 0 ;
14467  PyArrayObject *tmp1 = NULL ;
14468  PLFLT temp4 ;
14469  int res4 = SWIG_TMPOBJ ;
14470  PLFLT temp5 ;
14471  int res5 = SWIG_TMPOBJ ;
14472  PyObject *swig_obj[1] ;
14473 
14474  arg4 = &temp4;
14475  arg5 = &temp5;
14476  if (!args) SWIG_fail;
14477  swig_obj[0] = args;
14478  {
14479  int i, size;
14480  tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14481  if ( tmp1 == NULL )
14482  return NULL;
14483  Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14484  Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14485  size = arg3;
14486  arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14487  for ( i = 0; i < arg2; i++ )
14488  arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14489  }
14490  plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14491  resultobj = SWIG_Py_Void();
14492  if (SWIG_IsTmpObj(res4)) {
14493  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14494  } else {
14495  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14496  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14497  }
14498  if (SWIG_IsTmpObj(res5)) {
14499  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14500  } else {
14501  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14502  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14503  }
14504  {
14505  Py_CLEAR( tmp1 );
14506  free( arg1 );
14507  }
14508  return resultobj;
14509 fail:
14510  {
14511  Py_CLEAR( tmp1 );
14512  free( arg1 );
14513  }
14514  return NULL;
14515 }
14516 
14517 
14518 SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14519  PyObject *resultobj = 0;
14520  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14521  void *argp1 = 0 ;
14522  int res1 = 0 ;
14523  PyObject *swig_obj[1] ;
14524  PLINT result;
14525 
14526  if (!args) SWIG_fail;
14527  swig_obj[0] = args;
14528  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14529  if (!SWIG_IsOK(res1)) {
14530  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14531  }
14532  arg1 = (PLGraphicsIn *)(argp1);
14533  result = (PLINT)plGetCursor(arg1);
14534  resultobj = SWIG_From_int((int)(result));
14535  return resultobj;
14536 fail:
14537  return NULL;
14538 }
14539 
14540 
14541 static PyMethodDef SwigMethods[] = {
14542  { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
14543  { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14544  { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14545  { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14546  { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14547  { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
14548  { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14549  { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
14550  { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14551  { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
14552  { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14553  { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
14554  { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14555  { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
14556  { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14557  { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
14558  { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14559  { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
14560  { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14561  { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
14562  { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14563  { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
14564  { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14565  { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
14566  { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14567  { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
14568  { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14569  { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
14570  { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
14571  { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
14572  { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
14573  { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
14574  { "plsxwin", _wrap_plsxwin, METH_O, NULL},
14575  { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
14576  "Set format of numerical label for contours\n"
14577  "\n"
14578  "DESCRIPTION:\n"
14579  "\n"
14580  " Set format of numerical label for contours.\n"
14581  "\n"
14582  " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14583  "\n"
14584  " This function is used example 9.\n"
14585  "\n"
14586  "\n"
14587  "\n"
14588  "SYNOPSIS:\n"
14589  "\n"
14590  "pl_setcontlabelformat(lexp, sigdig)\n"
14591  "\n"
14592  "ARGUMENTS:\n"
14593  "\n"
14594  " lexp (PLINT, input) : If the contour numerical label is greater\n"
14595  " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14596  " format is used. Default value of lexp is 4.\n"
14597  "\n"
14598  " sigdig (PLINT, input) : Number of significant digits. Default\n"
14599  " value is 2.\n"
14600  "\n"
14601  ""},
14602  { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
14603  "Set parameters of contour labelling other than format of numerical label\n"
14604  "\n"
14605  "DESCRIPTION:\n"
14606  "\n"
14607  " Set parameters of contour labelling other than those handled by\n"
14608  " pl_setcontlabelformat.\n"
14609  "\n"
14610  " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14611  "\n"
14612  " This function is used in example 9.\n"
14613  "\n"
14614  "\n"
14615  "\n"
14616  "SYNOPSIS:\n"
14617  "\n"
14618  "pl_setcontlabelparam(offset, size, spacing, active)\n"
14619  "\n"
14620  "ARGUMENTS:\n"
14621  "\n"
14622  " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14623  " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
14624  "\n"
14625  " size (PLFLT, input) : Font height for contour labels (normalized).\n"
14626  " Default value is 0.3.\n"
14627  "\n"
14628  " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
14629  " Default value is 0.1.\n"
14630  "\n"
14631  " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14632  " contour labels on. Default is off (0).\n"
14633  "\n"
14634  ""},
14635  { "pladv", _wrap_pladv, METH_O, "\n"
14636  "Advance the (sub-)page\n"
14637  "\n"
14638  "DESCRIPTION:\n"
14639  "\n"
14640  " Advances to the next subpage if sub=0, performing a page advance if\n"
14641  " there are no remaining subpages on the current page. If subpages\n"
14642  " aren't being used, pladv(0) will always advance the page. If page>0,\n"
14643  " PLplot switches to the specified subpage. Note that this allows you\n"
14644  " to overwrite a plot on the specified subpage; if this is not what you\n"
14645  " intended, use pleop followed by plbop to first advance the page. This\n"
14646  " routine is called automatically (with page=0) by plenv, but if plenv\n"
14647  " is not used, pladv must be called after initializing PLplot but before\n"
14648  " defining the viewport.\n"
14649  "\n"
14650  " Redacted form: pladv(page)\n"
14651  "\n"
14652  " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
14653  " 29, and 31.\n"
14654  "\n"
14655  "\n"
14656  "\n"
14657  "SYNOPSIS:\n"
14658  "\n"
14659  "pladv(page)\n"
14660  "\n"
14661  "ARGUMENTS:\n"
14662  "\n"
14663  " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
14664  " in the top left corner and increasing along the rows) to which to\n"
14665  " advance. Set to zero to advance to the next subpage (or to the\n"
14666  " next page if subpages are not being used).\n"
14667  "\n"
14668  ""},
14669  { "plarc", _wrap_plarc, METH_VARARGS, "\n"
14670  "Draw a circular or elliptical arc\n"
14671  "\n"
14672  "DESCRIPTION:\n"
14673  "\n"
14674  " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14675  " semiminor axis b, starting at angle1 and ending at angle2.\n"
14676  "\n"
14677  " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14678  " fill)\n"
14679  "\n"
14680  "\n"
14681  " This function is used in examples 3 and 27.\n"
14682  "\n"
14683  "\n"
14684  "\n"
14685  "SYNOPSIS:\n"
14686  "\n"
14687  "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14688  "\n"
14689  "ARGUMENTS:\n"
14690  "\n"
14691  " x (PLFLT, input) : X coordinate of arc center.\n"
14692  "\n"
14693  " y (PLFLT, input) : Y coordinate of arc center.\n"
14694  "\n"
14695  " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
14696  "\n"
14697  " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
14698  "\n"
14699  " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14700  " semimajor axis.\n"
14701  "\n"
14702  " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14703  " semimajor axis.\n"
14704  "\n"
14705  " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14706  " X-axis.\n"
14707  "\n"
14708  " fill (PLBOOL, input) : Draw a filled arc.\n"
14709  "\n"
14710  ""},
14711  { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
14712  "Draw a box with axes, etc. with arbitrary origin\n"
14713  "\n"
14714  "DESCRIPTION:\n"
14715  "\n"
14716  " Draws a box around the currently defined viewport with arbitrary\n"
14717  " world-coordinate origin specified by x0 and y0 and labels it with\n"
14718  " world coordinate values appropriate to the window. Thus plaxes should\n"
14719  " only be called after defining both viewport and window. The ascii\n"
14720  " character strings xopt and yopt specify how the box should be drawn as\n"
14721  " described below. If ticks and/or subticks are to be drawn for a\n"
14722  " particular axis, the tick intervals and number of subintervals may be\n"
14723  " specified explicitly, or they may be defaulted by setting the\n"
14724  " appropriate arguments to zero.\n"
14725  "\n"
14726  " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14727  " ytick, nysub)\n"
14728  "\n"
14729  "\n"
14730  " This function is not used in any examples.\n"
14731  "\n"
14732  "\n"
14733  "\n"
14734  "SYNOPSIS:\n"
14735  "\n"
14736  "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14737  "\n"
14738  "ARGUMENTS:\n"
14739  "\n"
14740  " x0 (PLFLT, input) : World X coordinate of origin.\n"
14741  "\n"
14742  " y0 (PLFLT, input) : World Y coordinate of origin.\n"
14743  "\n"
14744  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14745  " options for the x axis. The string can include any combination of\n"
14746  " the following letters (upper or lower case) in any order: a: Draws\n"
14747  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14748  " (x=0).\n"
14749  " b: Draws bottom (X) or left (Y) edge of frame.\n"
14750  " c: Draws top (X) or right (Y) edge of frame.\n"
14751  " d: Plot labels as date / time. Values are assumed to be\n"
14752  " seconds since the epoch (as used by gmtime).\n"
14753  " f: Always use fixed point numeric labels.\n"
14754  " g: Draws a grid at the major tick interval.\n"
14755  " h: Draws a grid at the minor tick interval.\n"
14756  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14757  " inwards.\n"
14758  " l: Labels axis logarithmically. This only affects the labels,\n"
14759  " not the data, and so it is necessary to compute the logarithms\n"
14760  " of data points before passing them to any of the drawing\n"
14761  " routines.\n"
14762  " m: Writes numeric labels at major tick intervals in the\n"
14763  " unconventional location (above box for X, right of box for Y).\n"
14764  " n: Writes numeric labels at major tick intervals in the\n"
14765  " conventional location (below box for X, left of box for Y).\n"
14766  " o: Use custom labelling function to generate axis label text.\n"
14767  " The custom labelling function can be defined with the\n"
14768  " plslabelfunc command.\n"
14769  " s: Enables subticks between major ticks, only valid if t is\n"
14770  " also specified.\n"
14771  " t: Draws major ticks.\n"
14772  " u: Exactly like \"b\" except don't draw edge line.\n"
14773  " w: Exactly like \"c\" except don't draw edge line.\n"
14774  " x: Exactly like \"t\" (including the side effect of the\n"
14775  " numerical labels for the major ticks) except exclude drawing\n"
14776  " the major and minor tick marks.\n"
14777  "\n"
14778  "\n"
14779  " xtick (PLFLT, input) : World coordinate interval between major\n"
14780  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14781  " generates a suitable tick interval.\n"
14782  "\n"
14783  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14784  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14785  " generates a suitable minor tick interval.\n"
14786  "\n"
14787  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14788  " options for the y axis. The string can include any combination of\n"
14789  " the letters defined above for xopt, and in addition may contain:\n"
14790  " v: Write numeric labels for the y axis parallel to the base of the\n"
14791  " graph, rather than parallel to the axis.\n"
14792  "\n"
14793  "\n"
14794  " ytick (PLFLT, input) : World coordinate interval between major\n"
14795  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14796  " generates a suitable tick interval.\n"
14797  "\n"
14798  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14799  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14800  " generates a suitable minor tick interval.\n"
14801  "\n"
14802  ""},
14803  { "plbin", _wrap_plbin, METH_VARARGS, "\n"
14804  "Plot a histogram from binned data\n"
14805  "\n"
14806  "DESCRIPTION:\n"
14807  "\n"
14808  " Plots a histogram consisting of nbin bins. The value associated with\n"
14809  " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14810  " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14811  " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14812  " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14813  " placed midway between the values in the x vector. Also see plhist for\n"
14814  " drawing histograms from unbinned data.\n"
14815  "\n"
14816  " Redacted form: General: plbin(x, y, opt)\n"
14817  " Python: plbin(nbin, x, y, opt)\n"
14818  "\n"
14819  "\n"
14820  " This function is not used in any examples.\n"
14821  "\n"
14822  "\n"
14823  "\n"
14824  "SYNOPSIS:\n"
14825  "\n"
14826  "plbin(nbin, x, y, opt)\n"
14827  "\n"
14828  "ARGUMENTS:\n"
14829  "\n"
14830  " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14831  " and y vectors.)\n"
14832  "\n"
14833  " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
14834  " with bins. These must form a strictly increasing sequence.\n"
14835  "\n"
14836  " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
14837  " proportional to the number of points in each bin. This is a PLFLT\n"
14838  " (instead of PLINT) vector so as to allow histograms of\n"
14839  " probabilities, etc.\n"
14840  "\n"
14841  " opt (PLINT, input) : Is a combination of several flags:\n"
14842  " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14843  " outer bins are expanded to fill up the entire x-axis and bins of\n"
14844  " zero height are simply drawn.\n"
14845  " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14846  " between the x values. If the values in x are equally spaced,\n"
14847  " the values are the center values of the bins.\n"
14848  " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14849  " size as the ones inside.\n"
14850  " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14851  " (there is a gap for such bins).\n"
14852  "\n"
14853  ""},
14854  { "plbtime", _wrap_plbtime, METH_O, "\n"
14855  "Calculate broken-down time from continuous time for the current stream\n"
14856  "\n"
14857  "DESCRIPTION:\n"
14858  "\n"
14859  " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
14860  " continuous time, ctime for the current stream. This function is the\n"
14861  " inverse of plctime.\n"
14862  "\n"
14863  " The PLplot definition of broken-down time is a calendar time that\n"
14864  " completely ignores all time zone offsets, i.e., it is the user's\n"
14865  " responsibility to apply those offsets (if so desired) before using the\n"
14866  " PLplot time API. By default broken-down time is defined using the\n"
14867  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
14868  " continuous time is defined as the number of seconds since the Unix\n"
14869  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
14870  " broken-down and continuous time are possible, see plconfigtime.\n"
14871  "\n"
14872  " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
14873  " ctime)\n"
14874  "\n"
14875  "\n"
14876  " This function is used in example 29.\n"
14877  "\n"
14878  "\n"
14879  "\n"
14880  "SYNOPSIS:\n"
14881  "\n"
14882  "plbtime(year, month, day, hour, min, sec, ctime)\n"
14883  "\n"
14884  "ARGUMENTS:\n"
14885  "\n"
14886  " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
14887  " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
14888  " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
14889  " BCE, etc.)\n"
14890  "\n"
14891  " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
14892  " the year in the range from 0 (January) to 11 (December).\n"
14893  "\n"
14894  " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
14895  " month in the range from 1 to 31.\n"
14896  "\n"
14897  " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
14898  " day in the range from 0 to 23.\n"
14899  "\n"
14900  " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
14901  " hour in the range from 0 to 59\n"
14902  "\n"
14903  " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
14904  " minute in range from 0. to 60.\n"
14905  "\n"
14906  " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
14907  " time is calculated.\n"
14908  "\n"
14909  ""},
14910  { "plbop", _wrap_plbop, METH_NOARGS, "\n"
14911  "Begin a new page\n"
14912  "\n"
14913  "DESCRIPTION:\n"
14914  "\n"
14915  " Begins a new page. For a file driver, the output file is opened if\n"
14916  " necessary. Advancing the page via pleop and plbop is useful when a\n"
14917  " page break is desired at a particular point when plotting to subpages.\n"
14918  " Another use for pleop and plbop is when plotting pages to different\n"
14919  " files, since you can manually set the file name by calling plsfnam\n"
14920  " after the call to pleop. (In fact some drivers may only support a\n"
14921  " single page per file, making this a necessity.) One way to handle\n"
14922  " this case automatically is to page advance via pladv, but enable\n"
14923  " familying (see plsfam) with a small limit on the file size so that a\n"
14924  " new family member file will be created on each page break.\n"
14925  "\n"
14926  " Redacted form: plbop()\n"
14927  "\n"
14928  " This function is used in examples 2 and 20.\n"
14929  "\n"
14930  "\n"
14931  "\n"
14932  "SYNOPSIS:\n"
14933  "\n"
14934  "plbop()\n"
14935  "\n"
14936  ""},
14937  { "plbox", _wrap_plbox, METH_VARARGS, "\n"
14938  "Draw a box with axes, etc\n"
14939  "\n"
14940  "DESCRIPTION:\n"
14941  "\n"
14942  " Draws a box around the currently defined viewport, and labels it with\n"
14943  " world coordinate values appropriate to the window. Thus plbox should\n"
14944  " only be called after defining both viewport and window. The ascii\n"
14945  " character strings xopt and yopt specify how the box should be drawn as\n"
14946  " described below. If ticks and/or subticks are to be drawn for a\n"
14947  " particular axis, the tick intervals and number of subintervals may be\n"
14948  " specified explicitly, or they may be defaulted by setting the\n"
14949  " appropriate arguments to zero.\n"
14950  "\n"
14951  " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14952  "\n"
14953  "\n"
14954  " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
14955  " and 29.\n"
14956  "\n"
14957  "\n"
14958  "\n"
14959  "SYNOPSIS:\n"
14960  "\n"
14961  "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14962  "\n"
14963  "ARGUMENTS:\n"
14964  "\n"
14965  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14966  " options for the x axis. The string can include any combination of\n"
14967  " the following letters (upper or lower case) in any order: a: Draws\n"
14968  " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14969  " (x=0).\n"
14970  " b: Draws bottom (X) or left (Y) edge of frame.\n"
14971  " c: Draws top (X) or right (Y) edge of frame.\n"
14972  " d: Plot labels as date / time. Values are assumed to be\n"
14973  " seconds since the epoch (as used by gmtime).\n"
14974  " f: Always use fixed point numeric labels.\n"
14975  " g: Draws a grid at the major tick interval.\n"
14976  " h: Draws a grid at the minor tick interval.\n"
14977  " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14978  " inwards.\n"
14979  " l: Labels axis logarithmically. This only affects the labels,\n"
14980  " not the data, and so it is necessary to compute the logarithms\n"
14981  " of data points before passing them to any of the drawing\n"
14982  " routines.\n"
14983  " m: Writes numeric labels at major tick intervals in the\n"
14984  " unconventional location (above box for X, right of box for Y).\n"
14985  " n: Writes numeric labels at major tick intervals in the\n"
14986  " conventional location (below box for X, left of box for Y).\n"
14987  " o: Use custom labelling function to generate axis label text.\n"
14988  " The custom labelling function can be defined with the\n"
14989  " plslabelfunc command.\n"
14990  " s: Enables subticks between major ticks, only valid if t is\n"
14991  " also specified.\n"
14992  " t: Draws major ticks.\n"
14993  " u: Exactly like \"b\" except don't draw edge line.\n"
14994  " w: Exactly like \"c\" except don't draw edge line.\n"
14995  " x: Exactly like \"t\" (including the side effect of the\n"
14996  " numerical labels for the major ticks) except exclude drawing\n"
14997  " the major and minor tick marks.\n"
14998  "\n"
14999  "\n"
15000  " xtick (PLFLT, input) : World coordinate interval between major\n"
15001  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15002  " generates a suitable tick interval.\n"
15003  "\n"
15004  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15005  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15006  " generates a suitable minor tick interval.\n"
15007  "\n"
15008  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15009  " options for the y axis. The string can include any combination of\n"
15010  " the letters defined above for xopt, and in addition may contain:\n"
15011  " v: Write numeric labels for the y axis parallel to the base of the\n"
15012  " graph, rather than parallel to the axis.\n"
15013  "\n"
15014  "\n"
15015  " ytick (PLFLT, input) : World coordinate interval between major\n"
15016  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15017  " generates a suitable tick interval.\n"
15018  "\n"
15019  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15020  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15021  " generates a suitable minor tick interval.\n"
15022  "\n"
15023  ""},
15024  { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15025  "Draw a box with axes, etc, in 3-d\n"
15026  "\n"
15027  "DESCRIPTION:\n"
15028  "\n"
15029  " Draws axes, numeric and text labels for a three-dimensional surface\n"
15030  " plot. For a more complete description of three-dimensional plotting\n"
15031  " see the PLplot documentation.\n"
15032  "\n"
15033  " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15034  " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15035  "\n"
15036  "\n"
15037  " This function is used in examples 8, 11, 18, and 21.\n"
15038  "\n"
15039  "\n"
15040  "\n"
15041  "SYNOPSIS:\n"
15042  "\n"
15043  "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15044  "\n"
15045  "ARGUMENTS:\n"
15046  "\n"
15047  " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15048  " options for the x axis. The string can include any combination of\n"
15049  " the following letters (upper or lower case) in any order: b: Draws\n"
15050  " axis at base, at height z=\n"
15051  " zmin where zmin is defined by call to plw3d. This character must be\n"
15052  " specified in order to use any of the other options.\n"
15053  " d: Plot labels as date / time. Values are assumed to be\n"
15054  " seconds since the epoch (as used by gmtime).\n"
15055  " f: Always use fixed point numeric labels.\n"
15056  " i: Inverts tick marks, so they are drawn downwards, rather\n"
15057  " than upwards.\n"
15058  " l: Labels axis logarithmically. This only affects the labels,\n"
15059  " not the data, and so it is necessary to compute the logarithms\n"
15060  " of data points before passing them to any of the drawing\n"
15061  " routines.\n"
15062  " n: Writes numeric labels at major tick intervals.\n"
15063  " o: Use custom labelling function to generate axis label text.\n"
15064  " The custom labelling function can be defined with the\n"
15065  " plslabelfunc command.\n"
15066  " s: Enables subticks between major ticks, only valid if t is\n"
15067  " also specified.\n"
15068  " t: Draws major ticks.\n"
15069  " u: If this is specified, the text label for the axis is\n"
15070  " written under the axis.\n"
15071  "\n"
15072  "\n"
15073  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15074  " the text label for the x axis. It is only drawn if u is in the\n"
15075  " xopt string.\n"
15076  "\n"
15077  " xtick (PLFLT, input) : World coordinate interval between major\n"
15078  " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15079  " generates a suitable tick interval.\n"
15080  "\n"
15081  " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15082  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15083  " generates a suitable minor tick interval.\n"
15084  "\n"
15085  " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15086  " options for the y axis. The string is interpreted in the same way\n"
15087  " as xopt.\n"
15088  "\n"
15089  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15090  " the text label for the y axis. It is only drawn if u is in the\n"
15091  " yopt string.\n"
15092  "\n"
15093  " ytick (PLFLT, input) : World coordinate interval between major\n"
15094  " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15095  " generates a suitable tick interval.\n"
15096  "\n"
15097  " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15098  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15099  " generates a suitable minor tick interval.\n"
15100  "\n"
15101  " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15102  " options for the z axis. The string can include any combination of\n"
15103  " the following letters (upper or lower case) in any order: b: Draws\n"
15104  " z axis to the left of the surface plot.\n"
15105  " c: Draws z axis to the right of the surface plot.\n"
15106  " d: Draws grid lines parallel to the x-y plane behind the\n"
15107  " figure. These lines are not drawn until after plot3d or\n"
15108  " plmesh are called because of the need for hidden line removal.\n"
15109  " e: Plot labels as date / time. Values are assumed to be\n"
15110  " seconds since the epoch (as used by gmtime). Note this\n"
15111  " suboption is interpreted the same as the d suboption for xopt\n"
15112  " and yopt, but it has to be identified as e for zopt since d\n"
15113  " has already been used for the different purpose above.\n"
15114  " f: Always use fixed point numeric labels.\n"
15115  " i: Inverts tick marks, so they are drawn away from the center.\n"
15116  " l: Labels axis logarithmically. This only affects the labels,\n"
15117  " not the data, and so it is necessary to compute the logarithms\n"
15118  " of data points before passing them to any of the drawing\n"
15119  " routines.\n"
15120  " m: Writes numeric labels at major tick intervals on the\n"
15121  " right-hand z axis.\n"
15122  " n: Writes numeric labels at major tick intervals on the\n"
15123  " left-hand z axis.\n"
15124  " o: Use custom labelling function to generate axis label text.\n"
15125  " The custom labelling function can be defined with the\n"
15126  " plslabelfunc command.\n"
15127  " s: Enables subticks between major ticks, only valid if t is\n"
15128  " also specified.\n"
15129  " t: Draws major ticks.\n"
15130  " u: If this is specified, the text label is written beside the\n"
15131  " left-hand axis.\n"
15132  " v: If this is specified, the text label is written beside the\n"
15133  " right-hand axis.\n"
15134  "\n"
15135  "\n"
15136  " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15137  " the text label for the z axis. It is only drawn if u or v are in\n"
15138  " the zopt string.\n"
15139  "\n"
15140  " ztick (PLFLT, input) : World coordinate interval between major\n"
15141  " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15142  " generates a suitable tick interval.\n"
15143  "\n"
15144  " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15145  " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15146  " generates a suitable minor tick interval.\n"
15147  "\n"
15148  ""},
15149  { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15150  "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15151  "\n"
15152  "DESCRIPTION:\n"
15153  "\n"
15154  " Calculate world coordinates, wx and wy, and corresponding window index\n"
15155  " from relative device coordinates, rx and ry.\n"
15156  "\n"
15157  " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15158  "\n"
15159  "\n"
15160  " This function is used in example 31.\n"
15161  "\n"
15162  "\n"
15163  "\n"
15164  "SYNOPSIS:\n"
15165  "\n"
15166  "plcalc_world(rx, ry, wx, wy, window)\n"
15167  "\n"
15168  "ARGUMENTS:\n"
15169  "\n"
15170  " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15171  " the x coordinate.\n"
15172  "\n"
15173  " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15174  " the y coordinate.\n"
15175  "\n"
15176  " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15177  " coordinate corresponding to the relative device coordinates rx and\n"
15178  " ry.\n"
15179  "\n"
15180  " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15181  " coordinate corresponding to the relative device coordinates rx and\n"
15182  " ry.\n"
15183  "\n"
15184  " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15185  " defined window index that corresponds to the input relative device\n"
15186  " coordinates (and the returned world coordinates). To give some\n"
15187  " background on the window index, for each page the initial window\n"
15188  " index is set to zero, and each time plwind is called within the\n"
15189  " page, world and device coordinates are stored for the window and\n"
15190  " the window index is incremented. Thus, for a simple page layout\n"
15191  " with non-overlapping viewports and one window per viewport, window\n"
15192  " corresponds to the viewport index (in the order which the\n"
15193  " viewport/windows were created) of the only viewport/window\n"
15194  " corresponding to rx and ry. However, for more complicated layouts\n"
15195  " with potentially overlapping viewports and possibly more than one\n"
15196  " window (set of world coordinates) per viewport, window and the\n"
15197  " corresponding output world coordinates corresponds to the last\n"
15198  " window created that fulfills the criterion that the relative\n"
15199  " device coordinates are inside it. Finally, in all cases where the\n"
15200  " input relative device coordinates are not inside any\n"
15201  " viewport/window, then the returned value of the last defined\n"
15202  " window index is set to -1.\n"
15203  "\n"
15204  ""},
15205  { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15206  "Clear current (sub)page\n"
15207  "\n"
15208  "DESCRIPTION:\n"
15209  "\n"
15210  " Clears the current page, effectively erasing everything that have been\n"
15211  " drawn. This command only works with interactive drivers; if the\n"
15212  " driver does not support this, the page is filled with the background\n"
15213  " color in use. If the current page is divided into subpages, only the\n"
15214  " current subpage is erased. The nth subpage can be selected with\n"
15215  " pladv(n).\n"
15216  "\n"
15217  " Redacted form: General: plclear()\n"
15218  "\n"
15219  "\n"
15220  " This function is not used in any examples.\n"
15221  "\n"
15222  "\n"
15223  "\n"
15224  "SYNOPSIS:\n"
15225  "\n"
15226  "plclear()\n"
15227  "\n"
15228  ""},
15229  { "plcol0", _wrap_plcol0, METH_O, "\n"
15230  "Set color, cmap0\n"
15231  "\n"
15232  "DESCRIPTION:\n"
15233  "\n"
15234  " Sets the color index for cmap0 (see the PLplot documentation).\n"
15235  "\n"
15236  " Redacted form: plcol0(icol0)\n"
15237  "\n"
15238  " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15239  "\n"
15240  "\n"
15241  "\n"
15242  "SYNOPSIS:\n"
15243  "\n"
15244  "plcol0(icol0)\n"
15245  "\n"
15246  "ARGUMENTS:\n"
15247  "\n"
15248  " icol0 (PLINT, input) : Integer representing the color. The\n"
15249  " defaults at present are (these may change):\n"
15250  " 0 black (default background)\n"
15251  " 1 red (default foreground)\n"
15252  " 2 yellow\n"
15253  " 3 green\n"
15254  " 4 aquamarine\n"
15255  " 5 pink\n"
15256  " 6 wheat\n"
15257  " 7 grey\n"
15258  " 8 brown\n"
15259  " 9 blue\n"
15260  " 10 BlueViolet\n"
15261  " 11 cyan\n"
15262  " 12 turquoise\n"
15263  " 13 magenta\n"
15264  " 14 salmon\n"
15265  " 15 white\n"
15266  "\n"
15267  " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15268  " change an individual color in the cmap0 color palette.\n"
15269  "\n"
15270  ""},
15271  { "plcol1", _wrap_plcol1, METH_O, "\n"
15272  "Set color, cmap1\n"
15273  "\n"
15274  "DESCRIPTION:\n"
15275  "\n"
15276  " Sets the color for cmap1 (see the PLplot documentation).\n"
15277  "\n"
15278  " Redacted form: plcol1(col1)\n"
15279  "\n"
15280  " This function is used in examples 12 and 21.\n"
15281  "\n"
15282  "\n"
15283  "\n"
15284  "SYNOPSIS:\n"
15285  "\n"
15286  "plcol1(col1)\n"
15287  "\n"
15288  "ARGUMENTS:\n"
15289  "\n"
15290  " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15291  " is mapped to color using the continuous cmap1 palette which by\n"
15292  " default ranges from blue to the background color to red. The\n"
15293  " cmap1 palette can also be straightforwardly changed by the user\n"
15294  " with plscmap1 or plscmap1l.\n"
15295  "\n"
15296  ""},
15297  { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
15298  "Configure the transformation between continuous and broken-down time for the current stream\n"
15299  "\n"
15300  "DESCRIPTION:\n"
15301  "\n"
15302  " Configure the transformation between continuous and broken-down time\n"
15303  " for the current stream. This transformation is used by both plbtime\n"
15304  " and plctime.\n"
15305  "\n"
15306  " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15307  " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15308  "\n"
15309  "\n"
15310  " This function is used in example 29.\n"
15311  "\n"
15312  "\n"
15313  "\n"
15314  "SYNOPSIS:\n"
15315  "\n"
15316  "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15317  "\n"
15318  "ARGUMENTS:\n"
15319  "\n"
15320  " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15321  " As a special case, if\n"
15322  " scale is 0., then all other arguments are ignored, and the result (the\n"
15323  " default used by PLplot) is the equivalent of a call to\n"
15324  " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15325  " That is, for this special case broken-down time is calculated with\n"
15326  " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15327  " and the continuous time is defined as the number of seconds since\n"
15328  " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15329  "\n"
15330  " offset1 (PLFLT, input) : If\n"
15331  " ifbtime_offset is true, the parameters\n"
15332  " offset1 and\n"
15333  " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15334  " (with units in days) specify the epoch of the continuous time\n"
15335  " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15336  " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15337  " are used to specify the origin to allow users (by specifying\n"
15338  " offset1 as an integer that can be exactly represented by a\n"
15339  " floating-point variable and specifying\n"
15340  " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15341  " the numerical errors of the continuous time representation.\n"
15342  "\n"
15343  " offset2 (PLFLT, input) : See documentation of\n"
15344  " offset1.\n"
15345  "\n"
15346  " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15347  " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15348  " calendar is used for broken-down time rather than the proleptic\n"
15349  " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15350  " have been historically used to define UTC are inserted into the\n"
15351  " broken-down time. Other possibilities for additional control bits\n"
15352  " for ccontrol exist such as making the historical time corrections\n"
15353  " in the broken-down time corresponding to ET (ephemeris time) or\n"
15354  " making the (slightly non-constant) corrections from international\n"
15355  " atomic time (TAI) to what astronomers define as terrestrial time\n"
15356  " (TT). But those additional possibilities have not been\n"
15357  " implemented yet in the qsastime library (one of the PLplot utility\n"
15358  " libraries).\n"
15359  "\n"
15360  " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15361  " epoch of the continuous time scale is specified by the user. If\n"
15362  " ifbtime_offset is false, then\n"
15363  " offset1 and\n"
15364  " offset2 are used to specify the epoch, and the following broken-down\n"
15365  " time parameters are completely ignored. If\n"
15366  " ifbtime_offset is true, then\n"
15367  " offset1 and\n"
15368  " offset2 are completely ignored, and the following broken-down time\n"
15369  " parameters are used to specify the epoch.\n"
15370  "\n"
15371  " year (PLINT, input) : Year of epoch.\n"
15372  "\n"
15373  " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15374  " 11 (December).\n"
15375  "\n"
15376  " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15377  "\n"
15378  " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15379  "\n"
15380  " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15381  "\n"
15382  " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15383  "\n"
15384  ""},
15385  { "plcont", _wrap_plcont, METH_VARARGS, "\n"
15386  "Contour plot\n"
15387  "\n"
15388  "DESCRIPTION:\n"
15389  "\n"
15390  " Draws a contour plot of the data in f[\n"
15391  " nx][\n"
15392  " ny], using the nlevel contour levels specified by clevel. Only the\n"
15393  " region of the matrix from kx to lx and from ky to ly is plotted out\n"
15394  " where all these index ranges are interpreted as one-based for\n"
15395  " historical reasons. A transformation routine pointed to by pltr with\n"
15396  " a generic pointer pltr_data for additional data required by the\n"
15397  " transformation routine is used to map indices within the matrix to the\n"
15398  " world coordinates.\n"
15399  "\n"
15400  " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15401  " where (see above discussion) the pltr, pltr_data callback arguments\n"
15402  " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
15403  " vectors; or xg and yg matrices.\n"
15404  "\n"
15405  " This function is used in examples 9, 14, 16, and 22.\n"
15406  "\n"
15407  "\n"
15408  "\n"
15409  "SYNOPSIS:\n"
15410  "\n"
15411  "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15412  "\n"
15413  "ARGUMENTS:\n"
15414  "\n"
15415  " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
15416  "\n"
15417  " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
15418  "\n"
15419  " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
15420  " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
15421  " zero-based for historical backwards-compatibility reasons.\n"
15422  "\n"
15423  " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
15424  " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
15425  " zero-based for historical backwards-compatibility reasons.\n"
15426  "\n"
15427  " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
15428  " which to draw contours.\n"
15429  "\n"
15430  " nlevel (PLINT, input) : Number of contour levels to draw.\n"
15431  "\n"
15432  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
15433  " defines the transformation between the zero-based indices of the\n"
15434  " matrix f and the world coordinates.For the C case, transformation\n"
15435  " functions are provided in the PLplot library: pltr0 for the\n"
15436  " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
15437  " respectively defined by vectors and matrices. In addition, C\n"
15438  " callback routines for the transformation can be supplied by the\n"
15439  " user such as the mypltr function in examples/c/x09c.c which\n"
15440  " provides a general linear transformation between index coordinates\n"
15441  " and world coordinates.For languages other than C you should\n"
15442  " consult the PLplot documentation for the details concerning how\n"
15443  " PLTRANSFORM_callback arguments are interfaced. However, in\n"
15444  " general, a particular pattern of callback-associated arguments\n"
15445  " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
15446  " yg matrices are respectively interfaced to a linear-transformation\n"
15447  " routine similar to the above mypltr function; pltr1; and pltr2.\n"
15448  " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
15449  " the PLplot documentation) support native language callbacks for\n"
15450  " handling index to world-coordinate transformations. Examples of\n"
15451  " these various approaches are given in examples/<language>x09*,\n"
15452  " examples/<language>x16*, examples/<language>x20*,\n"
15453  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
15454  " supported languages.\n"
15455  "\n"
15456  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15457  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
15458  " that is externally supplied.\n"
15459  "\n"
15460  ""},
15461  { "plctime", _wrap_plctime, METH_VARARGS, "\n"
15462  "Calculate continuous time from broken-down time for the current stream\n"
15463  "\n"
15464  "DESCRIPTION:\n"
15465  "\n"
15466  " Calculate continuous time, ctime, from broken-down time for the\n"
15467  " current stream. The broken-down\n"
15468  " time is specified by the following parameters: year, month, day, hour,\n"
15469  " min, and sec. This function is the inverse of plbtime.\n"
15470  "\n"
15471  " The PLplot definition of broken-down time is a calendar time that\n"
15472  " completely ignores all time zone offsets, i.e., it is the user's\n"
15473  " responsibility to apply those offsets (if so desired) before using the\n"
15474  " PLplot time API. By default broken-down time is defined using the\n"
15475  " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15476  " continuous time is defined as the number of seconds since the Unix\n"
15477  " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15478  " broken-down and continuous time are possible, see plconfigtime which\n"
15479  " specifies that transformation for the current stream.\n"
15480  "\n"
15481  " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
15482  " ctime)\n"
15483  "\n"
15484  "\n"
15485  " This function is used in example 29.\n"
15486  "\n"
15487  "\n"
15488  "\n"
15489  "SYNOPSIS:\n"
15490  "\n"
15491  "plctime(year, month, day, hour, min, sec, ctime)\n"
15492  "\n"
15493  "ARGUMENTS:\n"
15494  "\n"
15495  " year (PLINT, input) : Input year.\n"
15496  "\n"
15497  " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
15498  " (December).\n"
15499  "\n"
15500  " day (PLINT, input) : Input day in range from 1 to 31.\n"
15501  "\n"
15502  " hour (PLINT, input) : Input hour in range from 0 to 23\n"
15503  "\n"
15504  " min (PLINT, input) : Input minute in range from 0 to 59.\n"
15505  "\n"
15506  " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
15507  "\n"
15508  " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
15509  " time calculated from the broken-down time specified by the\n"
15510  " previous parameters.\n"
15511  "\n"
15512  ""},
15513  { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
15514  "Copy state parameters from the reference stream to the current stream\n"
15515  "\n"
15516  "DESCRIPTION:\n"
15517  "\n"
15518  " Copies state parameters from the reference stream to the current\n"
15519  " stream. Tell driver interface to map device coordinates unless flags\n"
15520  " == 1.\n"
15521  "\n"
15522  " This function is used for making save files of selected plots (e.g.\n"
15523  " from the TK driver). After initializing, you can get a copy of the\n"
15524  " current plot to the specified device by switching to this stream and\n"
15525  " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15526  " appropriate. The plot buffer must have previously been enabled (done\n"
15527  " automatically by some display drivers, such as X).\n"
15528  "\n"
15529  " Redacted form: plcpstrm(iplsr, flags)\n"
15530  "\n"
15531  " This function is used in example 1,20.\n"
15532  "\n"
15533  "\n"
15534  "\n"
15535  "SYNOPSIS:\n"
15536  "\n"
15537  "plcpstrm(iplsr, flags)\n"
15538  "\n"
15539  "ARGUMENTS:\n"
15540  "\n"
15541  " iplsr (PLINT, input) : Number of reference stream.\n"
15542  "\n"
15543  " flags (PLBOOL, input) : If flags is set to true the device\n"
15544  " coordinates are not copied from the reference to current stream.\n"
15545  "\n"
15546  ""},
15547  { "plend", _wrap_plend, METH_NOARGS, "\n"
15548  "End plotting session\n"
15549  "\n"
15550  "DESCRIPTION:\n"
15551  "\n"
15552  " Ends a plotting session, tidies up all the output files, switches\n"
15553  " interactive devices back into text mode and frees up any memory that\n"
15554  " was allocated. Must be called before end of program.\n"
15555  "\n"
15556  " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15557  " wait state after a call to plend or other functions which trigger the\n"
15558  " end of a plot page. To avoid this, use the plspause function.\n"
15559  "\n"
15560  " Redacted form: plend()\n"
15561  "\n"
15562  " This function is used in all of the examples.\n"
15563  "\n"
15564  "\n"
15565  "\n"
15566  "SYNOPSIS:\n"
15567  "\n"
15568  "plend()\n"
15569  "\n"
15570  ""},
15571  { "plend1", _wrap_plend1, METH_NOARGS, "\n"
15572  "End plotting session for current stream\n"
15573  "\n"
15574  "DESCRIPTION:\n"
15575  "\n"
15576  " Ends a plotting session for the current output stream only. See\n"
15577  " plsstrm for more info.\n"
15578  "\n"
15579  " Redacted form: plend1()\n"
15580  "\n"
15581  " This function is used in examples 1 and 20.\n"
15582  "\n"
15583  "\n"
15584  "\n"
15585  "SYNOPSIS:\n"
15586  "\n"
15587  "plend1()\n"
15588  "\n"
15589  ""},
15590  { "plenv", _wrap_plenv, METH_VARARGS, "\n"
15591  "Set up standard window and draw box\n"
15592  "\n"
15593  "DESCRIPTION:\n"
15594  "\n"
15595  " Sets up plotter environment for simple graphs by calling pladv and\n"
15596  " setting up viewport and window to sensible default values. plenv\n"
15597  " leaves a standard margin (left-hand margin of eight character heights,\n"
15598  " and a margin around the other three sides of five character heights)\n"
15599  " around most graphs for axis labels and a title. When these defaults\n"
15600  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15601  " plvasp for setting up the viewport, plwind for defining the window,\n"
15602  " and plbox for drawing the box.\n"
15603  "\n"
15604  " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15605  "\n"
15606  " This function is used in example 1,3,9,13,14,19-22,29.\n"
15607  "\n"
15608  "\n"
15609  "\n"
15610  "SYNOPSIS:\n"
15611  "\n"
15612  "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15613  "\n"
15614  "ARGUMENTS:\n"
15615  "\n"
15616  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15617  " world coordinates).\n"
15618  "\n"
15619  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15620  " world coordinates).\n"
15621  "\n"
15622  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15623  " coordinates).\n"
15624  "\n"
15625  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15626  " coordinates).\n"
15627  "\n"
15628  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15629  " scales will not be set, the user must set up the scale before\n"
15630  " calling plenv using plsvpa, plvasp or other.\n"
15631  " 0: the x and y axes are scaled independently to use as much of\n"
15632  " the screen as possible.\n"
15633  " 1: the scales of the x and y axes are made equal.\n"
15634  " 2: the axis of the x and y axes are made equal, and the plot\n"
15635  " box will be square.\n"
15636  "\n"
15637  "\n"
15638  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15639  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15640  " -1: draw box only.\n"
15641  " 0: draw box, ticks, and numeric tick labels.\n"
15642  " 1: also draw coordinate axes at x=0 and y=0.\n"
15643  " 2: also draw a grid at major tick positions in both\n"
15644  " coordinates.\n"
15645  " 3: also draw a grid at minor tick positions in both\n"
15646  " coordinates.\n"
15647  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15648  " have to be converted to logarithms separately.)\n"
15649  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15650  " have to be converted to logarithms separately.)\n"
15651  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15652  " have to be converted to logarithms separately.)\n"
15653  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15654  " have to be converted to logarithms separately.)\n"
15655  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15656  " have to be converted to logarithms separately.)\n"
15657  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15658  " have to be converted to logarithms separately.)\n"
15659  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15660  " have to be converted to logarithms separately.)\n"
15661  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15662  " have to be converted to logarithms separately.)\n"
15663  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15664  " and y data have to be converted to logarithms separately.)\n"
15665  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15666  " and y data have to be converted to logarithms separately.)\n"
15667  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15668  " and y data have to be converted to logarithms separately.)\n"
15669  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15670  " and y data have to be converted to logarithms separately.)\n"
15671  " 40: same as 0 except date / time x labels.\n"
15672  " 41: same as 1 except date / time x labels.\n"
15673  " 42: same as 2 except date / time x labels.\n"
15674  " 43: same as 3 except date / time x labels.\n"
15675  " 50: same as 0 except date / time y labels.\n"
15676  " 51: same as 1 except date / time y labels.\n"
15677  " 52: same as 2 except date / time y labels.\n"
15678  " 53: same as 3 except date / time y labels.\n"
15679  " 60: same as 0 except date / time x and y labels.\n"
15680  " 61: same as 1 except date / time x and y labels.\n"
15681  " 62: same as 2 except date / time x and y labels.\n"
15682  " 63: same as 3 except date / time x and y labels.\n"
15683  " 70: same as 0 except custom x and y labels.\n"
15684  " 71: same as 1 except custom x and y labels.\n"
15685  " 72: same as 2 except custom x and y labels.\n"
15686  " 73: same as 3 except custom x and y labels.\n"
15687  "\n"
15688  ""},
15689  { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
15690  "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
15691  "\n"
15692  "DESCRIPTION:\n"
15693  "\n"
15694  " Sets up plotter environment for simple graphs by calling pladv and\n"
15695  " setting up viewport and window to sensible default values. plenv0\n"
15696  " leaves a standard margin (left-hand margin of eight character heights,\n"
15697  " and a margin around the other three sides of five character heights)\n"
15698  " around most graphs for axis labels and a title. When these defaults\n"
15699  " are not suitable, use the individual routines plvpas, plvpor, or\n"
15700  " plvasp for setting up the viewport, plwind for defining the window,\n"
15701  " and plbox for drawing the box.\n"
15702  "\n"
15703  " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15704  "\n"
15705  " This function is used in example 21.\n"
15706  "\n"
15707  "\n"
15708  "\n"
15709  "SYNOPSIS:\n"
15710  "\n"
15711  "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15712  "\n"
15713  "ARGUMENTS:\n"
15714  "\n"
15715  " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15716  " world coordinates).\n"
15717  "\n"
15718  " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15719  " world coordinates).\n"
15720  "\n"
15721  " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15722  " coordinates).\n"
15723  "\n"
15724  " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15725  " coordinates).\n"
15726  "\n"
15727  " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15728  " scales will not be set, the user must set up the scale before\n"
15729  " calling plenv0 using plsvpa, plvasp or other.\n"
15730  " 0: the x and y axes are scaled independently to use as much of\n"
15731  " the screen as possible.\n"
15732  " 1: the scales of the x and y axes are made equal.\n"
15733  " 2: the axis of the x and y axes are made equal, and the plot\n"
15734  " box will be square.\n"
15735  "\n"
15736  "\n"
15737  " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15738  " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15739  " -1: draw box only.\n"
15740  " 0: draw box, ticks, and numeric tick labels.\n"
15741  " 1: also draw coordinate axes at x=0 and y=0.\n"
15742  " 2: also draw a grid at major tick positions in both\n"
15743  " coordinates.\n"
15744  " 3: also draw a grid at minor tick positions in both\n"
15745  " coordinates.\n"
15746  " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15747  " have to be converted to logarithms separately.)\n"
15748  " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15749  " have to be converted to logarithms separately.)\n"
15750  " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15751  " have to be converted to logarithms separately.)\n"
15752  " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15753  " have to be converted to logarithms separately.)\n"
15754  " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15755  " have to be converted to logarithms separately.)\n"
15756  " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15757  " have to be converted to logarithms separately.)\n"
15758  " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15759  " have to be converted to logarithms separately.)\n"
15760  " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15761  " have to be converted to logarithms separately.)\n"
15762  " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15763  " and y data have to be converted to logarithms separately.)\n"
15764  " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15765  " and y data have to be converted to logarithms separately.)\n"
15766  " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15767  " and y data have to be converted to logarithms separately.)\n"
15768  " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15769  " and y data have to be converted to logarithms separately.)\n"
15770  " 40: same as 0 except date / time x labels.\n"
15771  " 41: same as 1 except date / time x labels.\n"
15772  " 42: same as 2 except date / time x labels.\n"
15773  " 43: same as 3 except date / time x labels.\n"
15774  " 50: same as 0 except date / time y labels.\n"
15775  " 51: same as 1 except date / time y labels.\n"
15776  " 52: same as 2 except date / time y labels.\n"
15777  " 53: same as 3 except date / time y labels.\n"
15778  " 60: same as 0 except date / time x and y labels.\n"
15779  " 61: same as 1 except date / time x and y labels.\n"
15780  " 62: same as 2 except date / time x and y labels.\n"
15781  " 63: same as 3 except date / time x and y labels.\n"
15782  " 70: same as 0 except custom x and y labels.\n"
15783  " 71: same as 1 except custom x and y labels.\n"
15784  " 72: same as 2 except custom x and y labels.\n"
15785  " 73: same as 3 except custom x and y labels.\n"
15786  "\n"
15787  ""},
15788  { "pleop", _wrap_pleop, METH_NOARGS, "\n"
15789  "Eject current page\n"
15790  "\n"
15791  "DESCRIPTION:\n"
15792  "\n"
15793  " Clears the graphics screen of an interactive device, or ejects a page\n"
15794  " on a plotter. See plbop for more information.\n"
15795  "\n"
15796  " Redacted form: pleop()\n"
15797  "\n"
15798  " This function is used in example 2,14.\n"
15799  "\n"
15800  "\n"
15801  "\n"
15802  "SYNOPSIS:\n"
15803  "\n"
15804  "pleop()\n"
15805  "\n"
15806  ""},
15807  { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
15808  "Draw error bars in x direction\n"
15809  "\n"
15810  "DESCRIPTION:\n"
15811  "\n"
15812  " Draws a set of n error bars in x direction, the i'th error bar\n"
15813  " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
15814  " of the error bars are of length equal to the minor tick length\n"
15815  " (settable using plsmin).\n"
15816  "\n"
15817  " Redacted form: General: plerrx(xmin, ymax, y)\n"
15818  "\n"
15819  "\n"
15820  " This function is used in example 29.\n"
15821  "\n"
15822  "\n"
15823  "\n"
15824  "SYNOPSIS:\n"
15825  "\n"
15826  "plerrx(n, xmin, xmax, y)\n"
15827  "\n"
15828  "ARGUMENTS:\n"
15829  "\n"
15830  " n (PLINT, input) : Number of error bars to draw.\n"
15831  "\n"
15832  " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15833  " of the left-hand endpoints of the error bars.\n"
15834  "\n"
15835  " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15836  " of the right-hand endpoints of the error bars.\n"
15837  "\n"
15838  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15839  " the error bars.\n"
15840  "\n"
15841  ""},
15842  { "plerry", _wrap_plerry, METH_VARARGS, "\n"
15843  "Draw error bars in the y direction\n"
15844  "\n"
15845  "DESCRIPTION:\n"
15846  "\n"
15847  " Draws a set of n error bars in the y direction, the i'th error bar\n"
15848  " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
15849  " of the error bars are of length equal to the minor tick length\n"
15850  " (settable using plsmin).\n"
15851  "\n"
15852  " Redacted form: General: plerry(x, ymin, ymax)\n"
15853  "\n"
15854  "\n"
15855  " This function is used in example 29.\n"
15856  "\n"
15857  "\n"
15858  "\n"
15859  "SYNOPSIS:\n"
15860  "\n"
15861  "plerry(n, x, ymin, ymax)\n"
15862  "\n"
15863  "ARGUMENTS:\n"
15864  "\n"
15865  " n (PLINT, input) : Number of error bars to draw.\n"
15866  "\n"
15867  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15868  " the error bars.\n"
15869  "\n"
15870  " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15871  " of the lower endpoints of the error bars.\n"
15872  "\n"
15873  " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15874  " of the upper endpoints of the error bars.\n"
15875  "\n"
15876  ""},
15877  { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
15878  "Advance to the next family file on the next new page\n"
15879  "\n"
15880  "DESCRIPTION:\n"
15881  "\n"
15882  " Advance to the next family file on the next new page.\n"
15883  "\n"
15884  " Redacted form: plfamadv()\n"
15885  "\n"
15886  " This function is not used in any examples.\n"
15887  "\n"
15888  "\n"
15889  "\n"
15890  "SYNOPSIS:\n"
15891  "\n"
15892  "plfamadv()\n"
15893  "\n"
15894  ""},
15895  { "plfill", _wrap_plfill, METH_VARARGS, "\n"
15896  "Draw filled polygon\n"
15897  "\n"
15898  "DESCRIPTION:\n"
15899  "\n"
15900  " Fills the polygon defined by the n points (\n"
15901  " x[i],\n"
15902  " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15903  " style is a solid fill. The routine will automatically close the\n"
15904  " polygon between the last and first vertices. If multiple closed\n"
15905  " polygons are passed in x and y then plfill will fill in between them.\n"
15906  "\n"
15907  " Redacted form: plfill(x,y)\n"
15908  "\n"
15909  " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
15910  "\n"
15911  "\n"
15912  "\n"
15913  "SYNOPSIS:\n"
15914  "\n"
15915  "plfill(n, x, y)\n"
15916  "\n"
15917  "ARGUMENTS:\n"
15918  "\n"
15919  " n (PLINT, input) : Number of vertices in polygon.\n"
15920  "\n"
15921  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15922  " vertices.\n"
15923  "\n"
15924  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15925  " vertices.\n"
15926  "\n"
15927  ""},
15928  { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
15929  "Draw filled polygon in 3D\n"
15930  "\n"
15931  "DESCRIPTION:\n"
15932  "\n"
15933  " Fills the 3D polygon defined by the n points in the x, y, and z\n"
15934  " vectors using the pattern defined by plpsty or plpat. The routine\n"
15935  " will automatically close the polygon between the last and first\n"
15936  " vertices. If multiple closed polygons are passed in x, y, and z then\n"
15937  " plfill3 will fill in between them.\n"
15938  "\n"
15939  " Redacted form: General: plfill3(x, y, z)\n"
15940  "\n"
15941  "\n"
15942  " This function is used in example 15.\n"
15943  "\n"
15944  "\n"
15945  "\n"
15946  "SYNOPSIS:\n"
15947  "\n"
15948  "plfill3(n, x, y, z)\n"
15949  "\n"
15950  "ARGUMENTS:\n"
15951  "\n"
15952  " n (PLINT, input) : Number of vertices in polygon.\n"
15953  "\n"
15954  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15955  " vertices.\n"
15956  "\n"
15957  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15958  " vertices.\n"
15959  "\n"
15960  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
15961  " vertices.\n"
15962  "\n"
15963  ""},
15964  { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
15965  "Draw linear gradient inside polygon\n"
15966  "\n"
15967  "DESCRIPTION:\n"
15968  "\n"
15969  " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
15970  " points (\n"
15971  " x[i],\n"
15972  " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
15973  " polygon coordinates and the gradient angle are all expressed in world\n"
15974  " coordinates. The angle from the x axis for both the rotated\n"
15975  " coordinate system and the gradient vector is specified by angle. The\n"
15976  " magnitude of the gradient vector is the difference between the maximum\n"
15977  " and minimum values of x for the vertices in the rotated coordinate\n"
15978  " system. The origin of the gradient vector can be interpreted as being\n"
15979  " anywhere on the line corresponding to the minimum x value for the\n"
15980  " vertices in the rotated coordinate system. The distance along the\n"
15981  " gradient vector is linearly transformed to the independent variable of\n"
15982  " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
15983  " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
15984  " color corresponding to the independent variable of cmap1. For more\n"
15985  " information about cmap1 (see the PLplot documentation).\n"
15986  "\n"
15987  " Redacted form: plgradient(x,y,angle)\n"
15988  "\n"
15989  " This function is used in examples 25 and 30.\n"
15990  "\n"
15991  "\n"
15992  "\n"
15993  "SYNOPSIS:\n"
15994  "\n"
15995  "plgradient(n, x, y, angle)\n"
15996  "\n"
15997  "ARGUMENTS:\n"
15998  "\n"
15999  " n (PLINT, input) : Number of vertices in polygon.\n"
16000  "\n"
16001  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16002  " vertices.\n"
16003  "\n"
16004  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16005  " vertices.\n"
16006  "\n"
16007  " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16008  " axis.\n"
16009  "\n"
16010  ""},
16011  { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16012  "Flushes the output stream\n"
16013  "\n"
16014  "DESCRIPTION:\n"
16015  "\n"
16016  " Flushes the output stream. Use sparingly, if at all.\n"
16017  "\n"
16018  " Redacted form: plflush()\n"
16019  "\n"
16020  " This function is used in examples 1 and 14.\n"
16021  "\n"
16022  "\n"
16023  "\n"
16024  "SYNOPSIS:\n"
16025  "\n"
16026  "plflush()\n"
16027  "\n"
16028  ""},
16029  { "plfont", _wrap_plfont, METH_O, "\n"
16030  "Set font\n"
16031  "\n"
16032  "DESCRIPTION:\n"
16033  "\n"
16034  " Sets the font used for subsequent text and symbols. For devices that\n"
16035  " still use Hershey fonts this routine has no effect unless the Hershey\n"
16036  " fonts with extended character set are loaded (see plfontld). For\n"
16037  " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16038  " this routine calls the plsfci routine with argument set up\n"
16039  " appropriately for the various cases below. However, this method of\n"
16040  " specifying the font for unicode-aware devices is deprecated, and the\n"
16041  " much more flexible method of calling plsfont directly is recommended\n"
16042  " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16043  "\n"
16044  " Redacted form: plfont(ifont)\n"
16045  "\n"
16046  " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16047  "\n"
16048  "\n"
16049  "\n"
16050  "SYNOPSIS:\n"
16051  "\n"
16052  "plfont(ifont)\n"
16053  "\n"
16054  "ARGUMENTS:\n"
16055  "\n"
16056  " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16057  " (simplest and fastest)\n"
16058  " 2: Serif font\n"
16059  " 3: Italic font\n"
16060  " 4: Script font\n"
16061  "\n"
16062  ""},
16063  { "plfontld", _wrap_plfontld, METH_O, "\n"
16064  "Load Hershey fonts\n"
16065  "\n"
16066  "DESCRIPTION:\n"
16067  "\n"
16068  " Loads the Hershey fonts used for text and symbols. This routine may\n"
16069  " be called before or after initializing PLplot. If not explicitly\n"
16070  " called before PLplot initialization, then by default that\n"
16071  " initialization loads Hershey fonts with the extended character set.\n"
16072  " This routine only has a practical effect for devices that still use\n"
16073  " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16074  " system fonts instead of Hershey fonts).\n"
16075  "\n"
16076  " Redacted form: plfontld(fnt)\n"
16077  "\n"
16078  " This function is used in examples 1 and 7.\n"
16079  "\n"
16080  "\n"
16081  "\n"
16082  "SYNOPSIS:\n"
16083  "\n"
16084  "plfontld(fnt)\n"
16085  "\n"
16086  "ARGUMENTS:\n"
16087  "\n"
16088  " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16089  " A zero value specifies Hershey fonts with the standard character\n"
16090  " set and a non-zero value (the default assumed if plfontld is never\n"
16091  " called) specifies Hershey fonts with the extended character set.\n"
16092  "\n"
16093  ""},
16094  { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16095  "Get character default height and current (scaled) height\n"
16096  "\n"
16097  "DESCRIPTION:\n"
16098  "\n"
16099  " Get character default height and current (scaled) height.\n"
16100  "\n"
16101  " Redacted form: plgchr(p_def, p_ht)\n"
16102  "\n"
16103  " This function is used in example 23.\n"
16104  "\n"
16105  "\n"
16106  "\n"
16107  "SYNOPSIS:\n"
16108  "\n"
16109  "plgchr(p_def, p_ht)\n"
16110  "\n"
16111  "ARGUMENTS:\n"
16112  "\n"
16113  " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16114  " character height (mm).\n"
16115  "\n"
16116  " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16117  " character height (mm).\n"
16118  "\n"
16119  ""},
16120  { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16121  "Returns 8-bit RGB values for given color index from cmap0\n"
16122  "\n"
16123  "DESCRIPTION:\n"
16124  "\n"
16125  " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16126  " PLplot documentation). Values are negative if an invalid color id is\n"
16127  " given.\n"
16128  "\n"
16129  " Redacted form: plgcol0(icol0, r, g, b)\n"
16130  "\n"
16131  " This function is used in example 2.\n"
16132  "\n"
16133  "\n"
16134  "\n"
16135  "SYNOPSIS:\n"
16136  "\n"
16137  "plgcol0(icol0, r, g, b)\n"
16138  "\n"
16139  "ARGUMENTS:\n"
16140  "\n"
16141  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16142  "\n"
16143  " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16144  " value.\n"
16145  "\n"
16146  " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16147  " value.\n"
16148  "\n"
16149  " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16150  " value.\n"
16151  "\n"
16152  ""},
16153  { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16154  "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16155  "\n"
16156  "DESCRIPTION:\n"
16157  "\n"
16158  " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16159  " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16160  " Values are negative if an invalid color id is given.\n"
16161  "\n"
16162  " Redacted form: plgcola(r, g, b)\n"
16163  "\n"
16164  " This function is used in example 30.\n"
16165  "\n"
16166  "\n"
16167  "\n"
16168  "SYNOPSIS:\n"
16169  "\n"
16170  "plgcol0a(icol0, r, g, b, alpha)\n"
16171  "\n"
16172  "ARGUMENTS:\n"
16173  "\n"
16174  " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16175  "\n"
16176  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16177  " in the range from 0 to 255.\n"
16178  "\n"
16179  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16180  " in the range from 0 to 255.\n"
16181  "\n"
16182  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16183  " in the range from 0 to 255.\n"
16184  "\n"
16185  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16186  " transparency in the range from (0.0-1.0).\n"
16187  "\n"
16188  ""},
16189  { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16190  "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16191  "\n"
16192  "DESCRIPTION:\n"
16193  "\n"
16194  " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16195  "\n"
16196  " Redacted form: plgcolbg(r, g, b)\n"
16197  "\n"
16198  " This function is used in example 31.\n"
16199  "\n"
16200  "\n"
16201  "\n"
16202  "SYNOPSIS:\n"
16203  "\n"
16204  "plgcolbg(r, g, b)\n"
16205  "\n"
16206  "ARGUMENTS:\n"
16207  "\n"
16208  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16209  " in the range from 0 to 255.\n"
16210  "\n"
16211  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16212  " in the range from 0 to 255.\n"
16213  "\n"
16214  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16215  " in the range from 0 to 255.\n"
16216  "\n"
16217  ""},
16218  { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16219  "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16220  "\n"
16221  "DESCRIPTION:\n"
16222  "\n"
16223  " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16224  " alpha transparency value.\n"
16225  "\n"
16226  " This function is used in example 31.\n"
16227  "\n"
16228  "\n"
16229  "\n"
16230  "SYNOPSIS:\n"
16231  "\n"
16232  "plgcolbga(r, g, b, alpha)\n"
16233  "\n"
16234  "ARGUMENTS:\n"
16235  "\n"
16236  " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16237  " in the range from 0 to 255.\n"
16238  "\n"
16239  " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16240  " in the range from 0 to 255.\n"
16241  "\n"
16242  " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16243  " in the range from 0 to 255.\n"
16244  "\n"
16245  " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16246  " transparency in the range (0.0-1.0).\n"
16247  "\n"
16248  ""},
16249  { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
16250  "Get the current device-compression setting\n"
16251  "\n"
16252  "DESCRIPTION:\n"
16253  "\n"
16254  " Get the current device-compression setting. This parameter is only\n"
16255  " used for drivers that provide compression.\n"
16256  "\n"
16257  " Redacted form: plgcompression(compression)\n"
16258  "\n"
16259  " This function is used in example 31.\n"
16260  "\n"
16261  "\n"
16262  "\n"
16263  "SYNOPSIS:\n"
16264  "\n"
16265  "plgcompression(compression)\n"
16266  "\n"
16267  "ARGUMENTS:\n"
16268  "\n"
16269  " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16270  " compression setting for the current device.\n"
16271  "\n"
16272  ""},
16273  { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
16274  "Get the current device (keyword) name\n"
16275  "\n"
16276  "DESCRIPTION:\n"
16277  "\n"
16278  " Get the current device (keyword) name. Note: you must have allocated\n"
16279  " space for this (80 characters is safe).\n"
16280  "\n"
16281  " Redacted form: plgdev(p_dev)\n"
16282  "\n"
16283  " This function is used in example 14.\n"
16284  "\n"
16285  "\n"
16286  "\n"
16287  "SYNOPSIS:\n"
16288  "\n"
16289  "plgdev(p_dev)\n"
16290  "\n"
16291  "ARGUMENTS:\n"
16292  "\n"
16293  " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16294  " (with preallocated length of 80 characters or more) containing the\n"
16295  " device (keyword) name.\n"
16296  "\n"
16297  ""},
16298  { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
16299  "Get parameters that define current device-space window\n"
16300  "\n"
16301  "DESCRIPTION:\n"
16302  "\n"
16303  " Get relative margin width, aspect ratio, and relative justification\n"
16304  " that define current device-space window. If plsdidev has not been\n"
16305  " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16306  " p_jy will all be 0.\n"
16307  "\n"
16308  " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16309  "\n"
16310  " This function is used in example 31.\n"
16311  "\n"
16312  "\n"
16313  "\n"
16314  "SYNOPSIS:\n"
16315  "\n"
16316  "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16317  "\n"
16318  "ARGUMENTS:\n"
16319  "\n"
16320  " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16321  " margin width.\n"
16322  "\n"
16323  " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16324  " ratio.\n"
16325  "\n"
16326  " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16327  " justification in x.\n"
16328  "\n"
16329  " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16330  " justification in y.\n"
16331  "\n"
16332  ""},
16333  { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
16334  "Get plot orientation\n"
16335  "\n"
16336  "DESCRIPTION:\n"
16337  "\n"
16338  " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16339  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16340  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16341  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16342  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16343  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16344  " not been called the default value pointed to by p_rot will be 0.\n"
16345  "\n"
16346  " Redacted form: plgdiori(p_rot)\n"
16347  "\n"
16348  " This function is not used in any examples.\n"
16349  "\n"
16350  "\n"
16351  "\n"
16352  "SYNOPSIS:\n"
16353  "\n"
16354  "plgdiori(p_rot)\n"
16355  "\n"
16356  "ARGUMENTS:\n"
16357  "\n"
16358  " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16359  " parameter.\n"
16360  "\n"
16361  ""},
16362  { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
16363  "Get parameters that define current plot-space window\n"
16364  "\n"
16365  "DESCRIPTION:\n"
16366  "\n"
16367  " Get relative minima and maxima that define current plot-space window.\n"
16368  " If plsdiplt has not been called the default values pointed to by\n"
16369  " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16370  "\n"
16371  " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16372  "\n"
16373  " This function is used in example 31.\n"
16374  "\n"
16375  "\n"
16376  "\n"
16377  "SYNOPSIS:\n"
16378  "\n"
16379  "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16380  "\n"
16381  "ARGUMENTS:\n"
16382  "\n"
16383  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16384  " minimum in x.\n"
16385  "\n"
16386  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16387  " minimum in y.\n"
16388  "\n"
16389  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16390  " maximum in x.\n"
16391  "\n"
16392  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16393  " maximum in y.\n"
16394  "\n"
16395  ""},
16396  { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
16397  "Get family file parameters\n"
16398  "\n"
16399  "DESCRIPTION:\n"
16400  "\n"
16401  " Gets information about current family file, if familying is enabled.\n"
16402  " See the PLplot documentation for more information.\n"
16403  "\n"
16404  " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16405  "\n"
16406  " This function is used in examples 14 and 31.\n"
16407  "\n"
16408  "\n"
16409  "\n"
16410  "SYNOPSIS:\n"
16411  "\n"
16412  "plgfam(p_fam, p_num, p_bmax)\n"
16413  "\n"
16414  "ARGUMENTS:\n"
16415  "\n"
16416  " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16417  " family flag value. If nonzero, familying is enabled for the\n"
16418  " current device.\n"
16419  "\n"
16420  " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16421  " family file number.\n"
16422  "\n"
16423  " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16424  " file size (in bytes) for a family file.\n"
16425  "\n"
16426  ""},
16427  { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
16428  "Get FCI (font characterization integer)\n"
16429  "\n"
16430  "DESCRIPTION:\n"
16431  "\n"
16432  " Gets information about the current font using the FCI approach. See\n"
16433  " the PLplot documentation for more information.\n"
16434  "\n"
16435  " Redacted form: plgfci(p_fci)\n"
16436  "\n"
16437  " This function is used in example 23.\n"
16438  "\n"
16439  "\n"
16440  "\n"
16441  "SYNOPSIS:\n"
16442  "\n"
16443  "plgfci(p_fci)\n"
16444  "\n"
16445  "ARGUMENTS:\n"
16446  "\n"
16447  " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
16448  " FCI value.\n"
16449  "\n"
16450  ""},
16451  { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
16452  "Get output file name\n"
16453  "\n"
16454  "DESCRIPTION:\n"
16455  "\n"
16456  " Gets the current output file name, if applicable.\n"
16457  "\n"
16458  " Redacted form: plgfnam(fnam)\n"
16459  "\n"
16460  " This function is used in example 31.\n"
16461  "\n"
16462  "\n"
16463  "\n"
16464  "SYNOPSIS:\n"
16465  "\n"
16466  "plgfnam(fnam)\n"
16467  "\n"
16468  "ARGUMENTS:\n"
16469  "\n"
16470  " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16471  " (with preallocated length of 80 characters or more) containing the\n"
16472  " file name.\n"
16473  "\n"
16474  ""},
16475  { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
16476  "Get family, style and weight of the current font\n"
16477  "\n"
16478  "DESCRIPTION:\n"
16479  "\n"
16480  " Gets information about current font. See the PLplot documentation for\n"
16481  " more information on font selection.\n"
16482  "\n"
16483  " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16484  "\n"
16485  " This function is used in example 23.\n"
16486  "\n"
16487  "\n"
16488  "\n"
16489  "SYNOPSIS:\n"
16490  "\n"
16491  "plgfont(p_family, p_style, p_weight)\n"
16492  "\n"
16493  "ARGUMENTS:\n"
16494  "\n"
16495  " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16496  " font family. The available values are given by the PL_FCI_*\n"
16497  " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16498  " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16499  " p_family is NULL then the font family is not returned.\n"
16500  "\n"
16501  " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16502  " font style. The available values are given by the PL_FCI_*\n"
16503  " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16504  " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
16505  " style is not returned.\n"
16506  "\n"
16507  " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16508  " font weight. The available values are given by the PL_FCI_*\n"
16509  " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16510  " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16511  " returned.\n"
16512  "\n"
16513  ""},
16514  { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
16515  "Get the (current) run level\n"
16516  "\n"
16517  "DESCRIPTION:\n"
16518  "\n"
16519  " Get the (current) run level. Valid settings are: 0, uninitialized\n"
16520  " 1, initialized\n"
16521  " 2, viewport defined\n"
16522  " 3, world coordinates defined\n"
16523  "\n"
16524  "\n"
16525  " Redacted form: plglevel(p_level)\n"
16526  "\n"
16527  " This function is used in example 31.\n"
16528  "\n"
16529  "\n"
16530  "\n"
16531  "SYNOPSIS:\n"
16532  "\n"
16533  "plglevel(p_level)\n"
16534  "\n"
16535  "ARGUMENTS:\n"
16536  "\n"
16537  " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
16538  " level.\n"
16539  "\n"
16540  ""},
16541  { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
16542  "Get page parameters\n"
16543  "\n"
16544  "DESCRIPTION:\n"
16545  "\n"
16546  " Gets the current page configuration. The length and offset values are\n"
16547  " expressed in units that are specific to the current driver. For\n"
16548  " instance: screen drivers will usually interpret them as number of\n"
16549  " pixels, whereas printer drivers will usually use mm.\n"
16550  "\n"
16551  " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16552  "\n"
16553  " This function is used in examples 14 and 31.\n"
16554  "\n"
16555  "\n"
16556  "\n"
16557  "SYNOPSIS:\n"
16558  "\n"
16559  "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16560  "\n"
16561  "ARGUMENTS:\n"
16562  "\n"
16563  " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16564  " pixels/inch (DPI) in x.\n"
16565  "\n"
16566  " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16567  " pixels/inch (DPI) in y.\n"
16568  "\n"
16569  " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16570  " length.\n"
16571  "\n"
16572  " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16573  " length.\n"
16574  "\n"
16575  " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16576  " offset.\n"
16577  "\n"
16578  " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16579  " offset.\n"
16580  "\n"
16581  ""},
16582  { "plgra", _wrap_plgra, METH_NOARGS, "\n"
16583  "Switch to graphics screen\n"
16584  "\n"
16585  "DESCRIPTION:\n"
16586  "\n"
16587  " Sets an interactive device to graphics mode, used in conjunction with\n"
16588  " pltext to allow graphics and text to be interspersed. On a device\n"
16589  " which supports separate text and graphics windows, this command causes\n"
16590  " control to be switched to the graphics window. If already in graphics\n"
16591  " mode, this command is ignored. It is also ignored on devices which\n"
16592  " only support a single window or use a different method for shifting\n"
16593  " focus. See also pltext.\n"
16594  "\n"
16595  " Redacted form: plgra()\n"
16596  "\n"
16597  " This function is used in example 1.\n"
16598  "\n"
16599  "\n"
16600  "\n"
16601  "SYNOPSIS:\n"
16602  "\n"
16603  "plgra()\n"
16604  "\n"
16605  ""},
16606  { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
16607  "Grid data from irregularly sampled data\n"
16608  "\n"
16609  "DESCRIPTION:\n"
16610  "\n"
16611  " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
16612  " require data organized as a grid, i.e., with x sample point values\n"
16613  " independent of y coordinate and vice versa. This function takes\n"
16614  " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
16615  " vectors; reads the desired grid location from the input vectors\n"
16616  " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
16617  " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
16618  " interpolate the data to the grid is specified with the argument type\n"
16619  " which can have one parameter specified in argument data.\n"
16620  "\n"
16621  " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16622  " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16623  "\n"
16624  "\n"
16625  " This function is used in example 21.\n"
16626  "\n"
16627  "\n"
16628  "\n"
16629  "SYNOPSIS:\n"
16630  "\n"
16631  "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16632  "\n"
16633  "ARGUMENTS:\n"
16634  "\n"
16635  " x (PLFLT_VECTOR, input) : The input x vector.\n"
16636  "\n"
16637  " y (PLFLT_VECTOR, input) : The input y vector.\n"
16638  "\n"
16639  " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
16640  " y[i], z[i] represents one data sample coordinate.\n"
16641  "\n"
16642  " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16643  " vectors.\n"
16644  "\n"
16645  " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16646  " in the x direction. Usually xg has nptsx equally spaced values\n"
16647  " from the minimum to the maximum values of the x input vector.\n"
16648  "\n"
16649  " nptsx (PLINT, input) : The number of points in the xg vector.\n"
16650  "\n"
16651  " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16652  " in the y direction. Similar to the xg parameter.\n"
16653  "\n"
16654  " nptsy (PLINT, input) : The number of points in the yg vector.\n"
16655  "\n"
16656  " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
16657  " where data lies in the grid specified by xg and yg. Therefore the\n"
16658  " zg matrix must be dimensioned\n"
16659  " nptsx by\n"
16660  " nptsy.\n"
16661  "\n"
16662  " type (PLINT, input) : The type of grid interpolation algorithm to\n"
16663  " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
16664  " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
16665  " GRID_NNI: Natural Neighbors Interpolation\n"
16666  " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
16667  " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
16668  " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16669  " Weighted\n"
16670  " For details of the algorithms read the source file plgridd.c.\n"
16671  "\n"
16672  " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16673  " which can be specified through this argument. Currently, for\n"
16674  " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16675  " use, the lower the value, the noisier (more local) the\n"
16676  " approximation is.\n"
16677  " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16678  " range [1. .. 2.]. High values enable the usage of very thin\n"
16679  " triangles for interpolation, possibly resulting in error in\n"
16680  " the approximation.\n"
16681  " GRID_NNI, only weights greater than data will be accepted. If\n"
16682  " 0, all weights will be accepted.\n"
16683  "\n"
16684  ""},
16685  { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
16686  "Get current subpage parameters\n"
16687  "\n"
16688  "DESCRIPTION:\n"
16689  "\n"
16690  " Gets the size of the current subpage in millimeters measured from the\n"
16691  " bottom left hand corner of the output device page or screen. Can be\n"
16692  " used in conjunction with plsvpa for setting the size of a viewport in\n"
16693  " absolute coordinates (millimeters).\n"
16694  "\n"
16695  " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16696  "\n"
16697  " This function is used in example 23.\n"
16698  "\n"
16699  "\n"
16700  "\n"
16701  "SYNOPSIS:\n"
16702  "\n"
16703  "plgspa(xmin, xmax, ymin, ymax)\n"
16704  "\n"
16705  "ARGUMENTS:\n"
16706  "\n"
16707  " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16708  " the left hand edge of the subpage in millimeters.\n"
16709  "\n"
16710  " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16711  " the right hand edge of the subpage in millimeters.\n"
16712  "\n"
16713  " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16714  " the bottom edge of the subpage in millimeters.\n"
16715  "\n"
16716  " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16717  " the top edge of the subpage in millimeters.\n"
16718  "\n"
16719  ""},
16720  { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
16721  "Get current stream number\n"
16722  "\n"
16723  "DESCRIPTION:\n"
16724  "\n"
16725  " Gets the number of the current output stream. See also plsstrm.\n"
16726  "\n"
16727  " Redacted form: plgstrm(p_strm)\n"
16728  "\n"
16729  " This function is used in example 1,20.\n"
16730  "\n"
16731  "\n"
16732  "\n"
16733  "SYNOPSIS:\n"
16734  "\n"
16735  "plgstrm(p_strm)\n"
16736  "\n"
16737  "ARGUMENTS:\n"
16738  "\n"
16739  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16740  " stream value.\n"
16741  "\n"
16742  ""},
16743  { "plgver", _wrap_plgver, METH_NOARGS, "\n"
16744  "Get the current library version number\n"
16745  "\n"
16746  "DESCRIPTION:\n"
16747  "\n"
16748  " Get the current library version number. Note: you must have allocated\n"
16749  " space for this (80 characters is safe).\n"
16750  "\n"
16751  " Redacted form: plgver(p_ver)\n"
16752  "\n"
16753  " This function is used in example 1.\n"
16754  "\n"
16755  "\n"
16756  "\n"
16757  "SYNOPSIS:\n"
16758  "\n"
16759  "plgver(p_ver)\n"
16760  "\n"
16761  "ARGUMENTS:\n"
16762  "\n"
16763  " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16764  " (with preallocated length of 80 characters or more) containing the\n"
16765  " PLplot version number.\n"
16766  "\n"
16767  ""},
16768  { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
16769  "Get viewport limits in normalized device coordinates\n"
16770  "\n"
16771  "DESCRIPTION:\n"
16772  "\n"
16773  " Get viewport limits in normalized device coordinates.\n"
16774  "\n"
16775  " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16776  "\n"
16777  "\n"
16778  " This function is used in example 31.\n"
16779  "\n"
16780  "\n"
16781  "\n"
16782  "SYNOPSIS:\n"
16783  "\n"
16784  "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16785  "\n"
16786  "ARGUMENTS:\n"
16787  "\n"
16788  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16789  " viewport limit of the normalized device coordinate in x.\n"
16790  "\n"
16791  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16792  " viewport limit of the normalized device coordinate in x.\n"
16793  "\n"
16794  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16795  " viewport limit of the normalized device coordinate in y.\n"
16796  "\n"
16797  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16798  " viewport limit of the normalized device coordinate in y.\n"
16799  "\n"
16800  ""},
16801  { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
16802  "Get viewport limits in world coordinates\n"
16803  "\n"
16804  "DESCRIPTION:\n"
16805  "\n"
16806  " Get viewport limits in world coordinates.\n"
16807  "\n"
16808  " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16809  "\n"
16810  "\n"
16811  " This function is used in example 31.\n"
16812  "\n"
16813  "\n"
16814  "\n"
16815  "SYNOPSIS:\n"
16816  "\n"
16817  "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16818  "\n"
16819  "ARGUMENTS:\n"
16820  "\n"
16821  " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16822  " viewport limit of the world coordinate in x.\n"
16823  "\n"
16824  " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16825  " viewport limit of the world coordinate in x.\n"
16826  "\n"
16827  " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16828  " viewport limit of the world coordinate in y.\n"
16829  "\n"
16830  " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16831  " viewport limit of the world coordinate in y.\n"
16832  "\n"
16833  ""},
16834  { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
16835  "Get x axis parameters\n"
16836  "\n"
16837  "DESCRIPTION:\n"
16838  "\n"
16839  " Returns current values of the p_digmax and p_digits flags for the x\n"
16840  " axis. p_digits is updated after the plot is drawn, so this routine\n"
16841  " should only be called after the call to plbox (or plbox3) is complete.\n"
16842  " See the PLplot documentation for more information.\n"
16843  "\n"
16844  " Redacted form: plgxax(p_digmax, p_digits)\n"
16845  "\n"
16846  " This function is used in example 31.\n"
16847  "\n"
16848  "\n"
16849  "\n"
16850  "SYNOPSIS:\n"
16851  "\n"
16852  "plgxax(p_digmax, p_digits)\n"
16853  "\n"
16854  "ARGUMENTS:\n"
16855  "\n"
16856  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16857  " number of digits for the x axis. If nonzero, the printed label\n"
16858  " has been switched to a floating-point representation when the\n"
16859  " number of digits exceeds this value.\n"
16860  "\n"
16861  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16862  " number of digits for the numeric labels (x axis) from the last\n"
16863  " plot.\n"
16864  "\n"
16865  ""},
16866  { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
16867  "Get y axis parameters\n"
16868  "\n"
16869  "DESCRIPTION:\n"
16870  "\n"
16871  " Identical to plgxax, except that arguments are flags for y axis. See\n"
16872  " the description of plgxax for more detail.\n"
16873  "\n"
16874  " Redacted form: plgyax(p_digmax, p_digits)\n"
16875  "\n"
16876  " This function is used in example 31.\n"
16877  "\n"
16878  "\n"
16879  "\n"
16880  "SYNOPSIS:\n"
16881  "\n"
16882  "plgyax(p_digmax, p_digits)\n"
16883  "\n"
16884  "ARGUMENTS:\n"
16885  "\n"
16886  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16887  " number of digits for the y axis. If nonzero, the printed label\n"
16888  " has been switched to a floating-point representation when the\n"
16889  " number of digits exceeds this value.\n"
16890  "\n"
16891  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16892  " number of digits for the numeric labels (y axis) from the last\n"
16893  " plot.\n"
16894  "\n"
16895  ""},
16896  { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
16897  "Get z axis parameters\n"
16898  "\n"
16899  "DESCRIPTION:\n"
16900  "\n"
16901  " Identical to plgxax, except that arguments are flags for z axis. See\n"
16902  " the description of plgxax for more detail.\n"
16903  "\n"
16904  " Redacted form: plgzax(p_digmax, p_digits)\n"
16905  "\n"
16906  " This function is used in example 31.\n"
16907  "\n"
16908  "\n"
16909  "\n"
16910  "SYNOPSIS:\n"
16911  "\n"
16912  "plgzax(p_digmax, p_digits)\n"
16913  "\n"
16914  "ARGUMENTS:\n"
16915  "\n"
16916  " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16917  " number of digits for the z axis. If nonzero, the printed label\n"
16918  " has been switched to a floating-point representation when the\n"
16919  " number of digits exceeds this value.\n"
16920  "\n"
16921  " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16922  " number of digits for the numeric labels (z axis) from the last\n"
16923  " plot.\n"
16924  "\n"
16925  ""},
16926  { "plhist", _wrap_plhist, METH_VARARGS, "\n"
16927  "Plot a histogram from unbinned data\n"
16928  "\n"
16929  "DESCRIPTION:\n"
16930  "\n"
16931  " Plots a histogram from n data points stored in the data vector. This\n"
16932  " routine bins the data into nbin bins equally spaced between datmin and\n"
16933  " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16934  " opt allows, among other things, the histogram either to be plotted in\n"
16935  " an existing window or causes plhist to call plenv with suitable limits\n"
16936  " before plotting the histogram.\n"
16937  "\n"
16938  " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16939  "\n"
16940  " This function is used in example 5.\n"
16941  "\n"
16942  "\n"
16943  "\n"
16944  "SYNOPSIS:\n"
16945  "\n"
16946  "plhist(n, data, datmin, datmax, nbin, opt)\n"
16947  "\n"
16948  "ARGUMENTS:\n"
16949  "\n"
16950  " n (PLINT, input) : Number of data points.\n"
16951  "\n"
16952  " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
16953  " n data points.\n"
16954  "\n"
16955  " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
16956  "\n"
16957  " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
16958  "\n"
16959  " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16960  " divide the interval xmin to xmax.\n"
16961  "\n"
16962  " opt (PLINT, input) : Is a combination of several flags:\n"
16963  " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16964  " the histogram data, the outer bins are expanded to fill up the\n"
16965  " entire x-axis, data outside the given extremes are assigned to the\n"
16966  " outer bins and bins of zero height are simply drawn.\n"
16967  " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
16968  " to fit the histogram data, without this flag, plenv is called\n"
16969  " to set the world coordinates.\n"
16970  " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
16971  " extremes are not taken into account. This option should\n"
16972  " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
16973  " properly present the data.\n"
16974  " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
16975  " size as the ones inside.\n"
16976  " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
16977  " (there is a gap for such bins).\n"
16978  "\n"
16979  ""},
16980  { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
16981  "Convert HLS color to RGB\n"
16982  "\n"
16983  "DESCRIPTION:\n"
16984  "\n"
16985  " Convert HLS color coordinates to RGB.\n"
16986  "\n"
16987  " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16988  "\n"
16989  "\n"
16990  " This function is used in example 2.\n"
16991  "\n"
16992  "\n"
16993  "\n"
16994  "SYNOPSIS:\n"
16995  "\n"
16996  "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
16997  "\n"
16998  "ARGUMENTS:\n"
16999  "\n"
17000  " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17001  " cylinder.\n"
17002  "\n"
17003  " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17004  " the axis of the color cylinder.\n"
17005  "\n"
17006  " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17007  " the radius of the color cylinder.\n"
17008  "\n"
17009  " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17010  " (0.0-1.0) of the color.\n"
17011  "\n"
17012  " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17013  " intensity (0.0-1.0) of the color.\n"
17014  "\n"
17015  " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17016  " intensity (0.0-1.0) of the color.\n"
17017  "\n"
17018  ""},
17019  { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17020  "Initialize PLplot\n"
17021  "\n"
17022  "DESCRIPTION:\n"
17023  "\n"
17024  " Initializing the plotting package. The program prompts for the device\n"
17025  " keyword or number of the desired output device. Hitting a RETURN in\n"
17026  " response to the prompt is the same as selecting the first device.\n"
17027  " plinit will issue no prompt if either the device was specified\n"
17028  " previously (via command line flag, the plsetopt function, or the\n"
17029  " plsdev function), or if only one device is enabled when PLplot is\n"
17030  " installed. If subpages have been specified, the output device is\n"
17031  " divided into nx by ny subpages, each of which may be used\n"
17032  " independently. If plinit is called again during a program, the\n"
17033  " previously opened file will be closed. The subroutine pladv is used\n"
17034  " to advance from one subpage to the next.\n"
17035  "\n"
17036  " Redacted form: plinit()\n"
17037  "\n"
17038  " This function is used in all of the examples.\n"
17039  "\n"
17040  "\n"
17041  "\n"
17042  "SYNOPSIS:\n"
17043  "\n"
17044  "plinit()\n"
17045  "\n"
17046  ""},
17047  { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17048  "Draw a line between two points\n"
17049  "\n"
17050  "DESCRIPTION:\n"
17051  "\n"
17052  " Joins the point (\n"
17053  " x1,\n"
17054  " y1) to (\n"
17055  " x2,\n"
17056  " y2).\n"
17057  "\n"
17058  " Redacted form: pljoin(x1,y1,x2,y2)\n"
17059  "\n"
17060  " This function is used in examples 3 and 14.\n"
17061  "\n"
17062  "\n"
17063  "\n"
17064  "SYNOPSIS:\n"
17065  "\n"
17066  "pljoin(x1, y1, x2, y2)\n"
17067  "\n"
17068  "ARGUMENTS:\n"
17069  "\n"
17070  " x1 (PLFLT, input) : x coordinate of first point.\n"
17071  "\n"
17072  " y1 (PLFLT, input) : y coordinate of first point.\n"
17073  "\n"
17074  " x2 (PLFLT, input) : x coordinate of second point.\n"
17075  "\n"
17076  " y2 (PLFLT, input) : y coordinate of second point.\n"
17077  "\n"
17078  ""},
17079  { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17080  "Simple routine to write labels\n"
17081  "\n"
17082  "DESCRIPTION:\n"
17083  "\n"
17084  " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17085  "\n"
17086  " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17087  "\n"
17088  " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17089  "\n"
17090  "\n"
17091  "\n"
17092  "SYNOPSIS:\n"
17093  "\n"
17094  "pllab(xlabel, ylabel, tlabel)\n"
17095  "\n"
17096  "ARGUMENTS:\n"
17097  "\n"
17098  " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17099  " the label for the x axis.\n"
17100  "\n"
17101  " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17102  " the label for the y axis.\n"
17103  "\n"
17104  " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17105  " the title of the plot.\n"
17106  "\n"
17107  ""},
17108  { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17109  "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17110  "\n"
17111  "DESCRIPTION:\n"
17112  "\n"
17113  " Routine for creating a discrete plot legend with a plotted filled box,\n"
17114  " line, and/or line of symbols for each annotated legend entry. (See\n"
17115  " plcolorbar for similar functionality for creating continuous color\n"
17116  " bars.) The arguments of pllegend provide control over the location\n"
17117  " and size of the legend as well as the location and characteristics of\n"
17118  " the elements (most of which are optional) within that legend. The\n"
17119  " resulting legend is clipped at the boundaries of the current subpage.\n"
17120  " (N.B. the adopted coordinate system used for some of the parameters is\n"
17121  " defined in the documentation of the position parameter.)\n"
17122  "\n"
17123  " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17124  " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17125  " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17126  " test_justification, text_colors, text, box_colors, box_patterns,\n"
17127  " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17128  " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17129  "\n"
17130  " This function is used in examples 4, 26, and 33.\n"
17131  "\n"
17132  "\n"
17133  "\n"
17134  "SYNOPSIS:\n"
17135  "\n"
17136  "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"
17137  "\n"
17138  "ARGUMENTS:\n"
17139  "\n"
17140  " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17141  " legend width in adopted coordinates. This quantity is calculated\n"
17142  " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17143  " the routine depending on nlegend and nrow), and the length\n"
17144  " (calculated internally) of the longest text string.\n"
17145  "\n"
17146  " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17147  " legend height in adopted coordinates. This quantity is calculated\n"
17148  " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17149  " the routine depending on nlegend and nrow).\n"
17150  "\n"
17151  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17152  " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17153  " on the left of the legend and the plotted area on the right.\n"
17154  " Otherwise, put the text area on the right of the legend and the\n"
17155  " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17156  " plot a (semitransparent) background for the legend. If the\n"
17157  " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17158  " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17159  " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17160  " plot the resulting array of legend entries in row-major order.\n"
17161  " Otherwise, plot the legend entries in column-major order.\n"
17162  "\n"
17163  " position (PLINT, input) : position contains bits which control the\n"
17164  " overall position of the legend and the definition of the adopted\n"
17165  " coordinates used for positions just like what is done for the\n"
17166  " position argument for plcolorbar. However, note that the defaults\n"
17167  " for the position bits (see below) are different than the\n"
17168  " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17169  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17170  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17171  " the 16 possible standard positions (the 4 corners and centers of\n"
17172  " the 4 sides for both the inside and outside cases) of the legend\n"
17173  " relative to the adopted coordinate system. The corner positions\n"
17174  " are specified by the appropriate combination of two of the\n"
17175  " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17176  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17177  " value of one of those bits. The adopted coordinates are\n"
17178  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17179  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17180  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17181  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17182  " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17183  " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17184  " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17185  " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17186  "\n"
17187  " x (PLFLT, input) : X offset of the legend position in adopted\n"
17188  " coordinates from the specified standard position of the legend.\n"
17189  " For positive x, the direction of motion away from the standard\n"
17190  " position is inward/outward from the standard corner positions or\n"
17191  " standard left or right positions if the\n"
17192  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17193  " For the standard top or bottom positions, the direction of motion\n"
17194  " is toward positive X.\n"
17195  "\n"
17196  " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17197  " coordinates from the specified standard position of the legend.\n"
17198  " For positive y, the direction of motion away from the standard\n"
17199  " position is inward/outward from the standard corner positions or\n"
17200  " standard top or bottom positions if the\n"
17201  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17202  " the standard left or right positions, the direction of motion is\n"
17203  " toward positive Y.\n"
17204  "\n"
17205  " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17206  " of the plot area (where the colored boxes, lines, and/or lines of\n"
17207  " symbols are drawn) of the legend.\n"
17208  "\n"
17209  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17210  " legend (PL_LEGEND_BACKGROUND).\n"
17211  "\n"
17212  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17213  " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17214  "\n"
17215  " bb_style (PLINT, input) : The pllsty style number for the\n"
17216  " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17217  "\n"
17218  " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17219  " render the\n"
17220  " nlegend legend entries. For internal transformations of\n"
17221  " nrow, see further remarks under\n"
17222  " nlegend.\n"
17223  "\n"
17224  " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17225  " to render the\n"
17226  " nlegend legend entries. For internal transformations of\n"
17227  " ncolumn, see further remarks under\n"
17228  " nlegend.\n"
17229  "\n"
17230  " nlegend (PLINT, input) : Number of legend entries. The above\n"
17231  " nrow and\n"
17232  " ncolumn values are transformed internally to be consistent with\n"
17233  " nlegend. If either\n"
17234  " nrow or\n"
17235  " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17236  " of\n"
17237  " nrow and\n"
17238  " ncolumn is less than\n"
17239  " nlegend, the smaller of the two (or\n"
17240  " nrow, if\n"
17241  " nrow ==\n"
17242  " ncolumn) is increased so the product is >=\n"
17243  " nlegend. Thus, for example, the common\n"
17244  " nrow = 0,\n"
17245  " ncolumn = 0 case is transformed internally to\n"
17246  " nrow =\n"
17247  " nlegend,\n"
17248  " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
17249  " column.\n"
17250  "\n"
17251  " opt_array (PLINT_VECTOR, input) : A vector of\n"
17252  " nlegend values of options to control each individual plotted area\n"
17253  " corresponding to a legend entry. If the\n"
17254  " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17255  " area. If the\n"
17256  " PL_LEGEND_COLOR_BOX,\n"
17257  " PL_LEGEND_LINE, and/or\n"
17258  " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17259  " entry is plotted with a colored box; a line; and/or a line of\n"
17260  " symbols.\n"
17261  "\n"
17262  " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17263  " area in units of character width.\n"
17264  "\n"
17265  " text_scale (PLFLT, input) : Character height scale for text\n"
17266  " annotations.\n"
17267  "\n"
17268  " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17269  " character height from one legend entry to the next.\n"
17270  "\n"
17271  " text_justification (PLFLT, input) : Justification parameter used\n"
17272  " for text justification. The most common values of\n"
17273  " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17274  " is left justified, centred, or right justified within the text\n"
17275  " area, but other values are allowed as well.\n"
17276  "\n"
17277  " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17278  " nlegend cmap0 text colors.\n"
17279  "\n"
17280  " text (PLCHAR_MATRIX, input) : A vector of\n"
17281  " nlegend UTF-8 character strings containing the legend annotations.\n"
17282  "\n"
17283  " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17284  " nlegend cmap0 colors for the discrete colored boxes (\n"
17285  " PL_LEGEND_COLOR_BOX).\n"
17286  "\n"
17287  " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17288  " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17289  " PL_LEGEND_COLOR_BOX).\n"
17290  "\n"
17291  " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17292  " nlegend scales (units of fraction of character height) for the height\n"
17293  " of the discrete colored boxes (\n"
17294  " PL_LEGEND_COLOR_BOX).\n"
17295  "\n"
17296  " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17297  " nlegend line widths for the patterns specified by box_patterns (\n"
17298  " PL_LEGEND_COLOR_BOX).\n"
17299  "\n"
17300  " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17301  " nlegend cmap0 line colors (\n"
17302  " PL_LEGEND_LINE).\n"
17303  "\n"
17304  " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17305  " nlegend line styles (plsty indices) (\n"
17306  " PL_LEGEND_LINE).\n"
17307  "\n"
17308  " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17309  " nlegend line widths (\n"
17310  " PL_LEGEND_LINE).\n"
17311  "\n"
17312  " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17313  " nlegend cmap0 symbol colors (\n"
17314  " PL_LEGEND_SYMBOL).\n"
17315  "\n"
17316  " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17317  " nlegend scale values for the symbol height (\n"
17318  " PL_LEGEND_SYMBOL).\n"
17319  "\n"
17320  " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17321  " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17322  " area (\n"
17323  " PL_LEGEND_SYMBOL).\n"
17324  "\n"
17325  " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17326  " nlegend UTF-8 character strings containing the legend symbols. (\n"
17327  " PL_LEGEND_SYMBOL).\n"
17328  "\n"
17329  ""},
17330  { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
17331  "Plot color bar for image, shade or gradient plots\n"
17332  "\n"
17333  "DESCRIPTION:\n"
17334  "\n"
17335  " Routine for creating a continuous color bar for image, shade, or\n"
17336  " gradient plots. (See pllegend for similar functionality for creating\n"
17337  " legends with discrete elements). The arguments of plcolorbar provide\n"
17338  " control over the location and size of the color bar as well as the\n"
17339  " location and characteristics of the elements (most of which are\n"
17340  " optional) within that color bar. The resulting color bar is clipped\n"
17341  " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17342  " system used for some of the parameters is defined in the documentation\n"
17343  " of the position parameter.)\n"
17344  "\n"
17345  " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17346  " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17347  " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17348  " labels, axis_opts, ticks, sub_ticks, values)\n"
17349  "\n"
17350  " This function is used in examples 16 and 33.\n"
17351  "\n"
17352  "\n"
17353  "\n"
17354  "SYNOPSIS:\n"
17355  "\n"
17356  "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"
17357  "\n"
17358  "ARGUMENTS:\n"
17359  "\n"
17360  " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17361  " labelled and decorated color bar width in adopted coordinates.\n"
17362  "\n"
17363  " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17364  " labelled and decorated color bar height in adopted coordinates.\n"
17365  "\n"
17366  " opt (PLINT, input) : opt contains bits controlling the overall\n"
17367  " color bar. The orientation (direction of the maximum value) of\n"
17368  " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17369  " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17370  " specified, the default orientation is toward the top if the\n"
17371  " colorbar is placed on the left or right of the viewport or toward\n"
17372  " the right if the colorbar is placed on the top or bottom of the\n"
17373  " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17374  " (semitransparent) background for the color bar. If the\n"
17375  " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17376  " color bar. The type of color bar must be specified with one of\n"
17377  " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17378  " more than one of those bits is set only the first one in the above\n"
17379  " list is honored. The position of the (optional) label/title can be\n"
17380  " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17381  " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17382  " will be drawn. If more than one of this list of bits is specified,\n"
17383  " only the first one on the list is honored. End-caps for the color\n"
17384  " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17385  " If a particular color bar cap option is not specified then no cap\n"
17386  " will be drawn for that end. As a special case for\n"
17387  " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17388  " specified. If this option is provided then any tick marks and tick\n"
17389  " labels will be placed at the breaks between shaded segments. TODO:\n"
17390  " This should be expanded to support custom placement of tick marks\n"
17391  " and tick labels at custom value locations for any color bar type.\n"
17392  "\n"
17393  " position (PLINT, input) : position contains bits which control the\n"
17394  " overall position of the color bar and the definition of the\n"
17395  " adopted coordinates used for positions just like what is done for\n"
17396  " the position argument for pllegend. However, note that the\n"
17397  " defaults for the position bits (see below) are different than the\n"
17398  " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17399  " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17400  " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17401  " the 16 possible standard positions (the 4 corners and centers of\n"
17402  " the 4 sides for both the inside and outside cases) of the color\n"
17403  " bar relative to the adopted coordinate system. The corner\n"
17404  " positions are specified by the appropriate combination of two of\n"
17405  " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17406  " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17407  " value of one of those bits. The adopted coordinates are\n"
17408  " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17409  " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17410  " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17411  " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17412  " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17413  " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17414  " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17415  " PL_POSITION_VIEWPORT.\n"
17416  "\n"
17417  " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17418  " coordinates from the specified standard position of the color bar.\n"
17419  " For positive x, the direction of motion away from the standard\n"
17420  " position is inward/outward from the standard corner positions or\n"
17421  " standard left or right positions if the\n"
17422  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17423  " For the standard top or bottom positions, the direction of motion\n"
17424  " is toward positive X.\n"
17425  "\n"
17426  " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17427  " coordinates from the specified standard position of the color bar.\n"
17428  " For positive y, the direction of motion away from the standard\n"
17429  " position is inward/outward from the standard corner positions or\n"
17430  " standard top or bottom positions if the\n"
17431  " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17432  " For the standard left or right positions, the direction of motion\n"
17433  " is toward positive Y.\n"
17434  "\n"
17435  " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17436  " the X direction in adopted coordinates.\n"
17437  "\n"
17438  " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17439  " the Y direction in adopted coordinates.\n"
17440  "\n"
17441  " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17442  " color bar (PL_COLORBAR_BACKGROUND).\n"
17443  "\n"
17444  " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17445  " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
17446  "\n"
17447  " bb_style (PLINT, input) : The pllsty style number for the\n"
17448  " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
17449  "\n"
17450  " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17451  " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
17452  "\n"
17453  " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17454  " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
17455  "\n"
17456  " cont_color (PLINT, input) : The cmap0 contour color for\n"
17457  " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17458  " it will be interpreted according to the design of plshades.\n"
17459  "\n"
17460  " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17461  " plots. This is passed directly to plshades, so it will be\n"
17462  " interpreted according to the design of plshades.\n"
17463  "\n"
17464  " n_labels (PLINT, input) : Number of labels to place around the\n"
17465  " color bar.\n"
17466  "\n"
17467  " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
17468  " n_labels labels.\n"
17469  "\n"
17470  " labels (PLCHAR_MATRIX, input) : A vector of\n"
17471  " n_labels UTF-8 character strings containing the labels for the color\n"
17472  " bar. Ignored if no label position is specified with one of the\n"
17473  " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17474  " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17475  " corresponding label_opts field.\n"
17476  "\n"
17477  " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17478  " value must be greater than 0. It is typically 1 (numerical axis\n"
17479  " labels are provided for one of the long edges of the color bar),\n"
17480  " but it can be larger if multiple numerical axis labels for the\n"
17481  " long edges of the color bar are desired.\n"
17482  "\n"
17483  " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
17484  " n_axes ascii character strings containing options (interpreted as for\n"
17485  " plbox) for the color bar's axis definitions.\n"
17486  "\n"
17487  " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
17488  " spacing of the major tick marks (interpreted as for plbox) for the\n"
17489  " color bar's axis definitions.\n"
17490  "\n"
17491  " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
17492  " number of subticks (interpreted as for plbox) for the color bar's\n"
17493  " axis definitions.\n"
17494  "\n"
17495  " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
17496  " elements in each of the n_axes rows of the values matrix.\n"
17497  "\n"
17498  " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
17499  " values for the data range represented by the color bar. For a row\n"
17500  " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
17501  " elements in the row is specified by n_values[i_axis]. For\n"
17502  " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
17503  " is 2, and the corresponding row elements of the values matrix are\n"
17504  " the minimum and maximum value represented by the colorbar. For\n"
17505  " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
17506  " of the values matrix is interpreted the same as the nlevel and\n"
17507  " clevel arguments of plshades.\n"
17508  "\n"
17509  ""},
17510  { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
17511  "Sets the 3D position of the light source\n"
17512  "\n"
17513  "DESCRIPTION:\n"
17514  "\n"
17515  " Sets the 3D position of the light source for use with plsurf3d and\n"
17516  " plsurf3dl\n"
17517  "\n"
17518  " Redacted form: pllightsource(x, y, z)\n"
17519  "\n"
17520  " This function is used in example 8.\n"
17521  "\n"
17522  "\n"
17523  "\n"
17524  "SYNOPSIS:\n"
17525  "\n"
17526  "pllightsource(x, y, z)\n"
17527  "\n"
17528  "ARGUMENTS:\n"
17529  "\n"
17530  " x (PLFLT, input) : X-coordinate of the light source.\n"
17531  "\n"
17532  " y (PLFLT, input) : Y-coordinate of the light source.\n"
17533  "\n"
17534  " z (PLFLT, input) : Z-coordinate of the light source.\n"
17535  "\n"
17536  ""},
17537  { "plline", _wrap_plline, METH_VARARGS, "\n"
17538  "Draw a line\n"
17539  "\n"
17540  "DESCRIPTION:\n"
17541  "\n"
17542  " Draws line defined by n points in x and y.\n"
17543  "\n"
17544  " Redacted form: plline(x, y)\n"
17545  "\n"
17546  " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
17547  " 25-27, and 29.\n"
17548  "\n"
17549  "\n"
17550  "\n"
17551  "SYNOPSIS:\n"
17552  "\n"
17553  "plline(n, x, y)\n"
17554  "\n"
17555  "ARGUMENTS:\n"
17556  "\n"
17557  " n (PLINT, input) : Number of points defining line.\n"
17558  "\n"
17559  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17560  " points.\n"
17561  "\n"
17562  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17563  " points.\n"
17564  "\n"
17565  ""},
17566  { "plline3", _wrap_plline3, METH_VARARGS, "\n"
17567  "Draw a line in 3 space\n"
17568  "\n"
17569  "DESCRIPTION:\n"
17570  "\n"
17571  " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17572  " first set up the viewport, the 2d viewing window (in world\n"
17573  " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17574  " more info.\n"
17575  "\n"
17576  " Redacted form: plline3(x, y, z)\n"
17577  "\n"
17578  " This function is used in example 18.\n"
17579  "\n"
17580  "\n"
17581  "\n"
17582  "SYNOPSIS:\n"
17583  "\n"
17584  "plline3(n, x, y, z)\n"
17585  "\n"
17586  "ARGUMENTS:\n"
17587  "\n"
17588  " n (PLINT, input) : Number of points defining line.\n"
17589  "\n"
17590  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17591  " points.\n"
17592  "\n"
17593  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17594  " points.\n"
17595  "\n"
17596  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
17597  " points.\n"
17598  "\n"
17599  ""},
17600  { "pllsty", _wrap_pllsty, METH_O, "\n"
17601  "Select line style\n"
17602  "\n"
17603  "DESCRIPTION:\n"
17604  "\n"
17605  " This sets the line style according to one of eight predefined patterns\n"
17606  " (also see plstyl).\n"
17607  "\n"
17608  " Redacted form: pllsty(lin)\n"
17609  "\n"
17610  " This function is used in examples 9, 12, 22, and 25.\n"
17611  "\n"
17612  "\n"
17613  "\n"
17614  "SYNOPSIS:\n"
17615  "\n"
17616  "pllsty(lin)\n"
17617  "\n"
17618  "ARGUMENTS:\n"
17619  "\n"
17620  " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
17621  " a continuous line, line style 2 is a line with short dashes and\n"
17622  " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17623  " 4 has long dashes and short gaps and so on.\n"
17624  "\n"
17625  ""},
17626  { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
17627  "Plot surface mesh\n"
17628  "\n"
17629  "DESCRIPTION:\n"
17630  "\n"
17631  " Plots a surface mesh within the environment set up by plw3d. The\n"
17632  " surface is defined by the matrix z[\n"
17633  " nx][\n"
17634  " ny] , the point z[i][j] being the value of the function at (\n"
17635  " x[i],\n"
17636  " y[j]). Note that the points in vectors x and y do not need to be\n"
17637  " equally spaced, but must be stored in ascending order. The parameter\n"
17638  " opt controls the way in which the surface is displayed. For further\n"
17639  " details see the PLplot documentation.\n"
17640  "\n"
17641  " Redacted form: plmesh(x, y, z, opt)\n"
17642  "\n"
17643  " This function is used in example 11.\n"
17644  "\n"
17645  "\n"
17646  "\n"
17647  "SYNOPSIS:\n"
17648  "\n"
17649  "plmesh(x, y, z, nx, ny, opt)\n"
17650  "\n"
17651  "ARGUMENTS:\n"
17652  "\n"
17653  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17654  " which the function is evaluated.\n"
17655  "\n"
17656  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17657  " which the function is evaluated.\n"
17658  "\n"
17659  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17660  " plot. Should have dimensions of\n"
17661  " nx by\n"
17662  " ny.\n"
17663  "\n"
17664  " nx (PLINT, input) : Number of x values at which function has been\n"
17665  " evaluated.\n"
17666  "\n"
17667  " ny (PLINT, input) : Number of y values at which function has been\n"
17668  " evaluated.\n"
17669  "\n"
17670  " opt (PLINT, input) : Determines the way in which the surface is\n"
17671  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17672  " function of x for each value of y[j] .\n"
17673  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17674  " for each value of x[i] .\n"
17675  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17676  " at which function is defined.\n"
17677  "\n"
17678  ""},
17679  { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
17680  "Magnitude colored plot surface mesh with contour\n"
17681  "\n"
17682  "DESCRIPTION:\n"
17683  "\n"
17684  " A more powerful form of plmesh: the surface mesh can be colored\n"
17685  " accordingly to the current z value being plotted, a contour plot can\n"
17686  " be drawn at the base XY plane, and a curtain can be drawn between the\n"
17687  " plotted function border and the base XY plane.\n"
17688  "\n"
17689  " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17690  "\n"
17691  " This function is used in example 11.\n"
17692  "\n"
17693  "\n"
17694  "\n"
17695  "SYNOPSIS:\n"
17696  "\n"
17697  "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17698  "\n"
17699  "ARGUMENTS:\n"
17700  "\n"
17701  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17702  " which the function is evaluated.\n"
17703  "\n"
17704  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17705  " which the function is evaluated.\n"
17706  "\n"
17707  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17708  " plot. Should have dimensions of\n"
17709  " nx by\n"
17710  " ny.\n"
17711  "\n"
17712  " nx (PLINT, input) : Number of x values at which function is\n"
17713  " evaluated.\n"
17714  "\n"
17715  " ny (PLINT, input) : Number of y values at which function is\n"
17716  " evaluated.\n"
17717  "\n"
17718  " opt (PLINT, input) : Determines the way in which the surface is\n"
17719  " represented. To specify more than one option just add the options,\n"
17720  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
17721  " showing z as a function of x for each value of y[j] .\n"
17722  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17723  " for each value of x[i] .\n"
17724  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17725  " at which function is defined.\n"
17726  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
17727  " the z value being plotted. The color is used from the current\n"
17728  " cmap1.\n"
17729  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
17730  " using parameters\n"
17731  " nlevel and\n"
17732  " clevel.\n"
17733  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
17734  " the borders of the plotted function.\n"
17735  "\n"
17736  "\n"
17737  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
17738  " levels.\n"
17739  "\n"
17740  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
17741  "\n"
17742  ""},
17743  { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
17744  "Creates a new stream and makes it the default\n"
17745  "\n"
17746  "DESCRIPTION:\n"
17747  "\n"
17748  " Creates a new stream and makes it the default. Differs from using\n"
17749  " plsstrm, in that a free stream number is found, and returned.\n"
17750  " Unfortunately, I have to start at stream 1 and work upward, since\n"
17751  " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17752  " that no initial, library-opening call is required. So stream 0 must\n"
17753  " be preallocated, and there is no simple way of determining whether it\n"
17754  " is already in use or not.\n"
17755  "\n"
17756  " Redacted form: plmkstrm(p_strm)\n"
17757  "\n"
17758  " This function is used in examples 1 and 20.\n"
17759  "\n"
17760  "\n"
17761  "\n"
17762  "SYNOPSIS:\n"
17763  "\n"
17764  "plmkstrm(p_strm)\n"
17765  "\n"
17766  "ARGUMENTS:\n"
17767  "\n"
17768  " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
17769  " number of the created stream.\n"
17770  "\n"
17771  ""},
17772  { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
17773  "Write text relative to viewport boundaries\n"
17774  "\n"
17775  "DESCRIPTION:\n"
17776  "\n"
17777  " Writes text at a specified position relative to the viewport\n"
17778  " boundaries. Text may be written inside or outside the viewport, but\n"
17779  " is clipped at the subpage boundaries. The reference point of a string\n"
17780  " lies along a line passing through the string at half the height of a\n"
17781  " capital letter. The position of the reference point along this line\n"
17782  " is determined by just, and the position of the reference point\n"
17783  " relative to the viewport is set by disp and pos.\n"
17784  "\n"
17785  " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17786  "\n"
17787  "\n"
17788  " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
17789  " 26.\n"
17790  "\n"
17791  "\n"
17792  "\n"
17793  "SYNOPSIS:\n"
17794  "\n"
17795  "plmtex(side, disp, pos, just, text)\n"
17796  "\n"
17797  "ARGUMENTS:\n"
17798  "\n"
17799  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17800  " the side of the viewport along which the text is to be written.\n"
17801  " The string must be one of: b: Bottom of viewport, text written\n"
17802  " parallel to edge.\n"
17803  " bv: Bottom of viewport, text written at right angles to edge.\n"
17804  " l: Left of viewport, text written parallel to edge.\n"
17805  " lv: Left of viewport, text written at right angles to edge.\n"
17806  " r: Right of viewport, text written parallel to edge.\n"
17807  " rv: Right of viewport, text written at right angles to edge.\n"
17808  " t: Top of viewport, text written parallel to edge.\n"
17809  " tv: Top of viewport, text written at right angles to edge.\n"
17810  "\n"
17811  "\n"
17812  " disp (PLFLT, input) : Position of the reference point of string,\n"
17813  " measured outwards from the specified viewport edge in units of the\n"
17814  " current character height. Use negative disp to write within the\n"
17815  " viewport.\n"
17816  "\n"
17817  " pos (PLFLT, input) : Position of the reference point of string\n"
17818  " along the specified edge, expressed as a fraction of the length of\n"
17819  " the edge.\n"
17820  "\n"
17821  " just (PLFLT, input) : Specifies the position of the string relative\n"
17822  " to its reference point. If just=0. , the reference point is at\n"
17823  " the left and if just=1. , it is at the right of the string. Other\n"
17824  " values of just give intermediate justifications.\n"
17825  "\n"
17826  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17827  " written out.\n"
17828  "\n"
17829  ""},
17830  { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
17831  "Write text relative to viewport boundaries in 3D plots\n"
17832  "\n"
17833  "DESCRIPTION:\n"
17834  "\n"
17835  " Writes text at a specified position relative to the viewport\n"
17836  " boundaries. Text may be written inside or outside the viewport, but\n"
17837  " is clipped at the subpage boundaries. The reference point of a string\n"
17838  " lies along a line passing through the string at half the height of a\n"
17839  " capital letter. The position of the reference point along this line\n"
17840  " is determined by just, and the position of the reference point\n"
17841  " relative to the viewport is set by disp and pos.\n"
17842  "\n"
17843  " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17844  "\n"
17845  " This function is used in example 28.\n"
17846  "\n"
17847  "\n"
17848  "\n"
17849  "SYNOPSIS:\n"
17850  "\n"
17851  "plmtex3(side, disp, pos, just, text)\n"
17852  "\n"
17853  "ARGUMENTS:\n"
17854  "\n"
17855  " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17856  " the side of the viewport along which the text is to be written.\n"
17857  " The string should contain one or more of the following characters:\n"
17858  " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
17859  " only label the X axis, not both the X and Y axes. x: Label the X\n"
17860  " axis.\n"
17861  " y: Label the Y axis.\n"
17862  " z: Label the Z axis.\n"
17863  " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17864  " For X it is the axis that starts at y-min. For Y it is the\n"
17865  " axis that starts at x-min.\n"
17866  " s: Label the secondary axis.\n"
17867  " v: Draw the text perpendicular to the axis.\n"
17868  "\n"
17869  "\n"
17870  " disp (PLFLT, input) : Position of the reference point of string,\n"
17871  " measured outwards from the specified viewport edge in units of the\n"
17872  " current character height. Use negative disp to write within the\n"
17873  " viewport.\n"
17874  "\n"
17875  " pos (PLFLT, input) : Position of the reference point of string\n"
17876  " along the specified edge, expressed as a fraction of the length of\n"
17877  " the edge.\n"
17878  "\n"
17879  " just (PLFLT, input) : Specifies the position of the string relative\n"
17880  " to its reference point. If just=0. , the reference point is at\n"
17881  " the left and if just=1. , it is at the right of the string. Other\n"
17882  " values of just give intermediate justifications.\n"
17883  "\n"
17884  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17885  " written out.\n"
17886  "\n"
17887  ""},
17888  { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
17889  "Plot 3-d surface plot\n"
17890  "\n"
17891  "DESCRIPTION:\n"
17892  "\n"
17893  " Plots a three-dimensional surface plot within the environment set up\n"
17894  " by plw3d. The surface is defined by the matrix z[\n"
17895  " nx][\n"
17896  " ny] , the point z[i][j] being the value of the function at (\n"
17897  " x[i],\n"
17898  " y[j]). Note that the points in vectors x and y do not need to be\n"
17899  " equally spaced, but must be stored in ascending order. The parameter\n"
17900  " opt controls the way in which the surface is displayed. For further\n"
17901  " details see the PLplot documentation. The only difference between\n"
17902  " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17903  " while plot3d only draws the surface as viewed from the top.\n"
17904  "\n"
17905  " Redacted form: plot3d(x, y, z, opt, side)\n"
17906  "\n"
17907  " This function is used in examples 11 and 21.\n"
17908  "\n"
17909  "\n"
17910  "\n"
17911  "SYNOPSIS:\n"
17912  "\n"
17913  "plot3d(x, y, z, nx, ny, opt, side)\n"
17914  "\n"
17915  "ARGUMENTS:\n"
17916  "\n"
17917  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17918  " which the function is evaluated.\n"
17919  "\n"
17920  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17921  " which the function is evaluated.\n"
17922  "\n"
17923  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17924  " plot. Should have dimensions of\n"
17925  " nx by\n"
17926  " ny.\n"
17927  "\n"
17928  " nx (PLINT, input) : Number of x values at which function is\n"
17929  " evaluated.\n"
17930  "\n"
17931  " ny (PLINT, input) : Number of y values at which function is\n"
17932  " evaluated.\n"
17933  "\n"
17934  " opt (PLINT, input) : Determines the way in which the surface is\n"
17935  " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17936  " function of x for each value of y[j] .\n"
17937  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17938  " for each value of x[i] .\n"
17939  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17940  " at which function is defined.\n"
17941  "\n"
17942  "\n"
17943  " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17944  " should be draw on the figure. If side is true sides are drawn,\n"
17945  " otherwise no sides are drawn.\n"
17946  "\n"
17947  ""},
17948  { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
17949  "Magnitude colored plot surface with contour\n"
17950  "\n"
17951  "DESCRIPTION:\n"
17952  "\n"
17953  " Aside from dropping the\n"
17954  " side functionality this is a more powerful form of plot3d: the surface\n"
17955  " mesh can be colored accordingly to the current z value being plotted,\n"
17956  " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
17957  " drawn between the plotted function border and the base XY plane. The\n"
17958  " arguments are identical to those of plmeshc. The only difference\n"
17959  " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
17960  " the surface, while plot3dc only draws the surface as viewed from the\n"
17961  " top.\n"
17962  "\n"
17963  " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17964  "\n"
17965  "\n"
17966  " This function is used in example 21.\n"
17967  "\n"
17968  "\n"
17969  "\n"
17970  "SYNOPSIS:\n"
17971  "\n"
17972  "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17973  "\n"
17974  "ARGUMENTS:\n"
17975  "\n"
17976  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17977  " which the function is evaluated.\n"
17978  "\n"
17979  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17980  " which the function is evaluated.\n"
17981  "\n"
17982  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17983  " plot. Should have dimensions of\n"
17984  " nx by\n"
17985  " ny.\n"
17986  "\n"
17987  " nx (PLINT, input) : Number of x values at which function is\n"
17988  " evaluated.\n"
17989  "\n"
17990  " ny (PLINT, input) : Number of y values at which function is\n"
17991  " evaluated.\n"
17992  "\n"
17993  " opt (PLINT, input) : Determines the way in which the surface is\n"
17994  " represented. To specify more than one option just add the options,\n"
17995  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
17996  " showing z as a function of x for each value of y[j] .\n"
17997  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17998  " for each value of x[i] .\n"
17999  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18000  " at which function is defined.\n"
18001  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18002  " the z value being plotted. The color is used from the current\n"
18003  " cmap1.\n"
18004  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18005  " using parameters\n"
18006  " nlevel and\n"
18007  " clevel.\n"
18008  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18009  " the borders of the plotted function.\n"
18010  "\n"
18011  "\n"
18012  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18013  " levels.\n"
18014  "\n"
18015  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18016  "\n"
18017  ""},
18018  { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18019  "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18020  "\n"
18021  "DESCRIPTION:\n"
18022  "\n"
18023  " When the implementation is completed this variant of plot3dc (see that\n"
18024  " function's documentation for more details) should be suitable for the\n"
18025  " case where the area of the x, y coordinate grid where z is defined can\n"
18026  " be non-rectangular. The implementation is incomplete so the last 4\n"
18027  " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18028  " indexymax; are currently ignored and the functionality is otherwise\n"
18029  " identical to that of plot3dc.\n"
18030  "\n"
18031  " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18032  " indexymin, indexymax)\n"
18033  "\n"
18034  "\n"
18035  " This function is not used in any example.\n"
18036  "\n"
18037  "\n"
18038  "\n"
18039  "SYNOPSIS:\n"
18040  "\n"
18041  "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18042  "\n"
18043  "ARGUMENTS:\n"
18044  "\n"
18045  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18046  " which the function is evaluated.\n"
18047  "\n"
18048  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18049  " which the function is evaluated.\n"
18050  "\n"
18051  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18052  " plot. Should have dimensions of\n"
18053  " nx by\n"
18054  " ny.\n"
18055  "\n"
18056  " nx (PLINT, input) : Number of x values at which the function is\n"
18057  " evaluated.\n"
18058  "\n"
18059  " ny (PLINT, input) : Number of y values at which the function is\n"
18060  " evaluated.\n"
18061  "\n"
18062  " opt (PLINT, input) : Determines the way in which the surface is\n"
18063  " represented. To specify more than one option just add the options,\n"
18064  " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18065  " showing z as a function of x for each value of y[j] .\n"
18066  " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18067  " for each value of x[i] .\n"
18068  " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18069  " at which function is defined.\n"
18070  " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18071  " the z value being plotted. The color is used from the current\n"
18072  " cmap1.\n"
18073  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18074  " using parameters\n"
18075  " nlevel and\n"
18076  " clevel.\n"
18077  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18078  " the borders of the plotted function.\n"
18079  "\n"
18080  "\n"
18081  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18082  " levels.\n"
18083  "\n"
18084  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18085  "\n"
18086  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18087  " corresponds to the first x index where z is defined.\n"
18088  "\n"
18089  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18090  " which corresponds (by convention) to one more than the last x\n"
18091  " index value where z is defined.\n"
18092  "\n"
18093  " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18094  " values which all must be ≥ 0. These values are the first y index\n"
18095  " where z is defined for a particular x index in the range from\n"
18096  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18097  " indexxmax.\n"
18098  "\n"
18099  " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18100  " values which all must be ≤ ny. These values correspond (by\n"
18101  " convention) to one more than the last y index where z is defined\n"
18102  " for a particular x index in the range from indexxmin to indexxmax\n"
18103  " - 1. The dimension of indexymax is indexxmax.\n"
18104  "\n"
18105  ""},
18106  { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18107  "Plot shaded 3-d surface plot\n"
18108  "\n"
18109  "DESCRIPTION:\n"
18110  "\n"
18111  " Plots a three-dimensional shaded surface plot within the environment\n"
18112  " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18113  " z[\n"
18114  " nx][\n"
18115  " ny], the point z[i][j] being the value of the function at (\n"
18116  " x[i],\n"
18117  " y[j]). Note that the points in vectors x and y do not need to be\n"
18118  " equally spaced, but must be stored in ascending order. For further\n"
18119  " details see the PLplot documentation.\n"
18120  "\n"
18121  " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18122  "\n"
18123  " This function is not used in any examples.\n"
18124  "\n"
18125  "\n"
18126  "\n"
18127  "SYNOPSIS:\n"
18128  "\n"
18129  "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18130  "\n"
18131  "ARGUMENTS:\n"
18132  "\n"
18133  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18134  " which the function is evaluated.\n"
18135  "\n"
18136  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18137  " which the function is evaluated.\n"
18138  "\n"
18139  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18140  " plot. Should have dimensions of\n"
18141  " nx by\n"
18142  " ny.\n"
18143  "\n"
18144  " nx (PLINT, input) : Number of x values at which function is\n"
18145  " evaluated.\n"
18146  "\n"
18147  " ny (PLINT, input) : Number of y values at which function is\n"
18148  " evaluated.\n"
18149  "\n"
18150  " opt (PLINT, input) : Determines the way in which the surface is\n"
18151  " represented. To specify more than one option just add the options,\n"
18152  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18153  " connecting points at which function is defined.\n"
18154  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18155  " using parameters\n"
18156  " nlevel and\n"
18157  " clevel.\n"
18158  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18159  " using parameters\n"
18160  " nlevel and\n"
18161  " clevel.\n"
18162  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18163  " the borders of the plotted function.\n"
18164  " opt=MAG_COLOR : the surface is colored according to the value\n"
18165  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18166  " according to the intensity of the reflected light in the\n"
18167  " surface from a light source whose position is set using\n"
18168  " pllightsource.\n"
18169  "\n"
18170  "\n"
18171  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18172  " levels.\n"
18173  "\n"
18174  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18175  "\n"
18176  ""},
18177  { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18178  "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18179  "\n"
18180  "DESCRIPTION:\n"
18181  "\n"
18182  " This variant of plsurf3d (see that function's documentation for more\n"
18183  " details) should be suitable for the case where the area of the x, y\n"
18184  " coordinate grid where z is defined can be non-rectangular. The limits\n"
18185  " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18186  " indexymin, and indexymax.\n"
18187  "\n"
18188  " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18189  " indexymax)\n"
18190  "\n"
18191  " This function is used in example 8.\n"
18192  "\n"
18193  "\n"
18194  "\n"
18195  "SYNOPSIS:\n"
18196  "\n"
18197  "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18198  "\n"
18199  "ARGUMENTS:\n"
18200  "\n"
18201  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18202  " which the function is evaluated.\n"
18203  "\n"
18204  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18205  " which the function is evaluated.\n"
18206  "\n"
18207  " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18208  " plot. Should have dimensions of\n"
18209  " nx by\n"
18210  " ny.\n"
18211  "\n"
18212  " nx (PLINT, input) : Number of x values at which function is\n"
18213  " evaluated.\n"
18214  "\n"
18215  " ny (PLINT, input) : Number of y values at which function is\n"
18216  " evaluated.\n"
18217  "\n"
18218  " opt (PLINT, input) : Determines the way in which the surface is\n"
18219  " represented. To specify more than one option just add the options,\n"
18220  " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18221  " connecting points at which function is defined.\n"
18222  " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18223  " using parameters\n"
18224  " nlevel and\n"
18225  " clevel.\n"
18226  " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18227  " using parameters\n"
18228  " nlevel and\n"
18229  " clevel.\n"
18230  " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18231  " the borders of the plotted function.\n"
18232  " opt=MAG_COLOR : the surface is colored according to the value\n"
18233  " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18234  " according to the intensity of the reflected light in the\n"
18235  " surface from a light source whose position is set using\n"
18236  " pllightsource.\n"
18237  "\n"
18238  "\n"
18239  " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18240  " levels.\n"
18241  "\n"
18242  " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18243  "\n"
18244  " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18245  " corresponds to the first x index where z is defined.\n"
18246  "\n"
18247  " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18248  " which corresponds (by convention) to one more than the last x\n"
18249  " index value where z is defined.\n"
18250  "\n"
18251  " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18252  " values which all must be ≥ 0. These values are the first y index\n"
18253  " where z is defined for a particular x index in the range from\n"
18254  " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18255  " indexxmax.\n"
18256  "\n"
18257  " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18258  " values which all must be ≤ ny. These values correspond (by\n"
18259  " convention) to one more than the last y index where z is defined\n"
18260  " for a particular x index in the range from indexxmin to indexxmax\n"
18261  " - 1. The dimension of indexymax is indexxmax.\n"
18262  "\n"
18263  ""},
18264  { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
18265  "Parse command-line arguments\n"
18266  "\n"
18267  "DESCRIPTION:\n"
18268  "\n"
18269  " Parse command-line arguments.\n"
18270  "\n"
18271  " plparseopts removes all recognized flags (decreasing argc\n"
18272  " accordingly), so that invalid input may be readily detected. It can\n"
18273  " also be used to process user command line flags. The user can merge\n"
18274  " an option table of type PLOptionTable into the internal option table\n"
18275  " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18276  " the external table(s) be parsed by calling plClearOpts before\n"
18277  " plMergeOpts.\n"
18278  "\n"
18279  " The default action taken by plparseopts is as follows:\n"
18280  " Returns with an error if an unrecognized option or badly formed\n"
18281  " option-value pair are encountered.\n"
18282  " Returns immediately (return code 0) when the first non-option command\n"
18283  " line argument is found.\n"
18284  " Returns with the return code of the option handler, if one was called.\n"
18285  "\n"
18286  " Deletes command line arguments from argv list as they are found, and\n"
18287  " decrements argc accordingly.\n"
18288  " Does not show \"invisible\" options in usage or help messages.\n"
18289  " Assumes the program name is contained in argv[0].\n"
18290  "\n"
18291  " These behaviors may be controlled through the\n"
18292  " mode argument.\n"
18293  "\n"
18294  " Redacted form: General: plparseopts(argv, mode)\n"
18295  "\n"
18296  "\n"
18297  " This function is used in all of the examples.\n"
18298  "\n"
18299  "\n"
18300  "\n"
18301  "SYNOPSIS:\n"
18302  "\n"
18303  "PLINT plparseopts(p_argc, argv, mode)\n"
18304  "\n"
18305  "ARGUMENTS:\n"
18306  "\n"
18307  " p_argc (int *, input/output) : Number of arguments.\n"
18308  "\n"
18309  " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18310  " strings containing *p_argc command-line arguments.\n"
18311  "\n"
18312  " mode (PLINT, input) : Parsing mode with the following\n"
18313  " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18314  " and all error messages enabled, including program exit when an\n"
18315  " error occurs. Anything on the command line that isn't recognized\n"
18316  " as a valid option or option argument is flagged as an error.\n"
18317  " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18318  " of errors.\n"
18319  " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18320  " arguments.\n"
18321  " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18322  " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18323  " pointer to the program name.\n"
18324  " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18325  " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18326  " unrecognized arguments.\n"
18327  "\n"
18328  ""},
18329  { "plpat", _wrap_plpat, METH_VARARGS, "\n"
18330  "Set area line fill pattern\n"
18331  "\n"
18332  "DESCRIPTION:\n"
18333  "\n"
18334  " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18335  " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18336  " inclinations and spacings. The arguments to this routine are the\n"
18337  " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18338  " elements) specifying the inclinations in tenths of a degree and the\n"
18339  " spacing in micrometers. (See also plpsty)\n"
18340  "\n"
18341  " Redacted form: General: plpat(inc, del)\n"
18342  "\n"
18343  "\n"
18344  " This function is used in example 15.\n"
18345  "\n"
18346  "\n"
18347  "\n"
18348  "SYNOPSIS:\n"
18349  "\n"
18350  "plpat(nlin, inc, del)\n"
18351  "\n"
18352  "ARGUMENTS:\n"
18353  "\n"
18354  " nlin (PLINT, input) : Number of sets of lines making up the\n"
18355  " pattern, either 1 or 2.\n"
18356  "\n"
18357  " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18358  " inclination in tenths of a degree. (Should be between -900 and\n"
18359  " 900).\n"
18360  "\n"
18361  " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18362  " spacing in micrometers between the lines making up the pattern.\n"
18363  "\n"
18364  ""},
18365  { "plpath", _wrap_plpath, METH_VARARGS, "\n"
18366  "Draw a line between two points, accounting for coordinate transforms\n"
18367  "\n"
18368  "DESCRIPTION:\n"
18369  "\n"
18370  " Joins the point (\n"
18371  " x1,\n"
18372  " y1) to (\n"
18373  " x2,\n"
18374  " y2) . If a global coordinate transform is defined then the line is\n"
18375  " broken in to n segments to approximate the path. If no transform is\n"
18376  " defined then this simply acts like a call to pljoin.\n"
18377  "\n"
18378  " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18379  "\n"
18380  " This function is used in example 22.\n"
18381  "\n"
18382  "\n"
18383  "\n"
18384  "SYNOPSIS:\n"
18385  "\n"
18386  "plpath(n, x1, y1, x2, y2)\n"
18387  "\n"
18388  "ARGUMENTS:\n"
18389  "\n"
18390  " n (PLINT, input) : number of points to use to approximate the path.\n"
18391  "\n"
18392  " x1 (PLFLT, input) : x coordinate of first point.\n"
18393  "\n"
18394  " y1 (PLFLT, input) : y coordinate of first point.\n"
18395  "\n"
18396  " x2 (PLFLT, input) : x coordinate of second point.\n"
18397  "\n"
18398  " y2 (PLFLT, input) : y coordinate of second point.\n"
18399  "\n"
18400  ""},
18401  { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
18402  "Plot a glyph at the specified points\n"
18403  "\n"
18404  "DESCRIPTION:\n"
18405  "\n"
18406  " Plot a glyph at the specified points. (This function is largely\n"
18407  " superseded by plstring which gives access to many[!] more glyphs.)\n"
18408  " code=-1 means try to just draw a point. Right now it's just a move\n"
18409  " and a draw at the same place. Not ideal, since a sufficiently\n"
18410  " intelligent output device may optimize it away, or there may be faster\n"
18411  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18412  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18413  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18414  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18415  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18416  "\n"
18417  " Redacted form: plpoin(x, y, code)\n"
18418  "\n"
18419  " This function is used in examples 1, 6, 14, and 29.\n"
18420  "\n"
18421  "\n"
18422  "\n"
18423  "SYNOPSIS:\n"
18424  "\n"
18425  "plpoin(n, x, y, code)\n"
18426  "\n"
18427  "ARGUMENTS:\n"
18428  "\n"
18429  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18430  "\n"
18431  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18432  " points.\n"
18433  "\n"
18434  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18435  " points.\n"
18436  "\n"
18437  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18438  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18439  " each of the n points.\n"
18440  "\n"
18441  ""},
18442  { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
18443  "Plot a glyph at the specified 3D points\n"
18444  "\n"
18445  "DESCRIPTION:\n"
18446  "\n"
18447  " Plot a glyph at the specified 3D points. (This function is largely\n"
18448  " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18449  " Set up the call to this function similar to what is done for plline3.\n"
18450  " code=-1 means try to just draw a point. Right now it's just a move\n"
18451  " and a draw at the same place. Not ideal, since a sufficiently\n"
18452  " intelligent output device may optimize it away, or there may be faster\n"
18453  " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18454  " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18455  " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18456  " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18457  " code <= 127 the corresponding printable ASCII character is plotted.\n"
18458  "\n"
18459  " Redacted form: plpoin3(x, y, z, code)\n"
18460  "\n"
18461  " This function is not used in any example.\n"
18462  "\n"
18463  "\n"
18464  "\n"
18465  "SYNOPSIS:\n"
18466  "\n"
18467  "plpoin3(n, x, y, z, code)\n"
18468  "\n"
18469  "ARGUMENTS:\n"
18470  "\n"
18471  " n (PLINT, input) : Number of points in the x and y vectors.\n"
18472  "\n"
18473  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18474  " points.\n"
18475  "\n"
18476  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18477  " points.\n"
18478  "\n"
18479  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18480  " points.\n"
18481  "\n"
18482  " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18483  " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18484  " each of the n points.\n"
18485  "\n"
18486  ""},
18487  { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
18488  "Draw a polygon in 3 space\n"
18489  "\n"
18490  "DESCRIPTION:\n"
18491  "\n"
18492  " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18493  " like plline3, but differs from that function in that plpoly3 attempts\n"
18494  " to determine if the polygon is viewable depending on the order of the\n"
18495  " points within the vector and the value of ifcc. If the back of\n"
18496  " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18497  " you want, then use plline3 instead.\n"
18498  "\n"
18499  " The points are assumed to be in a plane, and the directionality of the\n"
18500  " plane is determined from the first three points. Additional points do\n"
18501  " not have to lie on the plane defined by the first three, but if they\n"
18502  " do not, then the determination of visibility obviously can't be 100%\n"
18503  " accurate... So if you're 3 space polygons are too far from planar,\n"
18504  " consider breaking them into smaller polygons. 3 points define a plane\n"
18505  " :-).\n"
18506  "\n"
18507  " Bugs: If one of the first two segments is of zero length, or if they\n"
18508  " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18509  " being correct. Avoid such situations :-). See x18c.c for an example\n"
18510  " of this problem. (Search for 20.1).\n"
18511  "\n"
18512  " Redacted form: plpoly3(x, y, z, code)\n"
18513  "\n"
18514  " This function is used in example 18.\n"
18515  "\n"
18516  "\n"
18517  "\n"
18518  "SYNOPSIS:\n"
18519  "\n"
18520  "plpoly3(n, x, y, z, draw, ifcc)\n"
18521  "\n"
18522  "ARGUMENTS:\n"
18523  "\n"
18524  " n (PLINT, input) : Number of points defining line.\n"
18525  "\n"
18526  " x (PLFLT_VECTOR, input) : A vector containing\n"
18527  " n x coordinates of points.\n"
18528  "\n"
18529  " y (PLFLT_VECTOR, input) : A vector containing\n"
18530  " n y coordinates of points.\n"
18531  "\n"
18532  " z (PLFLT_VECTOR, input) : A vector containing\n"
18533  " n z coordinates of points.\n"
18534  "\n"
18535  " draw (PLBOOL_VECTOR, input) : A vector containing\n"
18536  " n-1 Boolean values which control drawing the segments of the polygon.\n"
18537  " If draw[i] is true, then the polygon segment from index [i] to\n"
18538  " [i+1] is drawn, otherwise, not.\n"
18539  "\n"
18540  " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18541  " polygon is determined by assuming the points are laid out in a\n"
18542  " counter-clockwise order. Otherwise, the directionality of the\n"
18543  " polygon is determined by assuming the points are laid out in a\n"
18544  " clockwise order.\n"
18545  "\n"
18546  ""},
18547  { "plprec", _wrap_plprec, METH_VARARGS, "\n"
18548  "Set precision in numeric labels\n"
18549  "\n"
18550  "DESCRIPTION:\n"
18551  "\n"
18552  " Sets the number of places after the decimal point in numeric labels.\n"
18553  "\n"
18554  " Redacted form: plprec(setp, prec)\n"
18555  "\n"
18556  " This function is used in example 29.\n"
18557  "\n"
18558  "\n"
18559  "\n"
18560  "SYNOPSIS:\n"
18561  "\n"
18562  "plprec(setp, prec)\n"
18563  "\n"
18564  "ARGUMENTS:\n"
18565  "\n"
18566  " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
18567  " automatically determines the number of places to use after the\n"
18568  " decimal point in numeric labels (like those used to label axes).\n"
18569  " If setp is 1 then prec sets the number of places.\n"
18570  "\n"
18571  " prec (PLINT, input) : The number of characters to draw after the\n"
18572  " decimal point in numeric labels.\n"
18573  "\n"
18574  ""},
18575  { "plpsty", _wrap_plpsty, METH_O, "\n"
18576  "Select area fill pattern\n"
18577  "\n"
18578  "DESCRIPTION:\n"
18579  "\n"
18580  " If\n"
18581  " patt is zero or less use either a hardware solid fill if the drivers\n"
18582  " have that capability (virtually all do) or fall back to a software\n"
18583  " emulation of a solid fill using the eighth area line fill pattern. If\n"
18584  " 0 <\n"
18585  " patt <= 8, then select one of eight predefined area line fill patterns\n"
18586  " to use (see plpat if you desire other patterns).\n"
18587  "\n"
18588  " Redacted form: plpsty(patt)\n"
18589  "\n"
18590  " This function is used in examples 12, 13, 15, 16, and 25.\n"
18591  "\n"
18592  "\n"
18593  "\n"
18594  "SYNOPSIS:\n"
18595  "\n"
18596  "plpsty(patt)\n"
18597  "\n"
18598  "ARGUMENTS:\n"
18599  "\n"
18600  " patt (PLINT, input) : The desired pattern index. If\n"
18601  " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
18602  " above) used. For\n"
18603  " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
18604  " line fill capability itself (most deliberately do not so that line\n"
18605  " fill patterns look identical for those drivers), the patterns\n"
18606  " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
18607  " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
18608  " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
18609  " (8) lines at both 45 degrees and -45 degrees.\n"
18610  "\n"
18611  ""},
18612  { "plptex", _wrap_plptex, METH_VARARGS, "\n"
18613  "Write text inside the viewport\n"
18614  "\n"
18615  "DESCRIPTION:\n"
18616  "\n"
18617  " Writes text at a specified position and inclination within the\n"
18618  " viewport. Text is clipped at the viewport boundaries. The reference\n"
18619  " point of a string lies along a line passing through the string at half\n"
18620  " the height of a capital letter. The position of the reference point\n"
18621  " along this line is determined by just, the reference point is placed\n"
18622  " at world coordinates (\n"
18623  " x,\n"
18624  " y) within the viewport. The inclination of the string is specified\n"
18625  " in terms of differences of world coordinates making it easy to write\n"
18626  " text parallel to a line in a graph.\n"
18627  "\n"
18628  " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18629  "\n"
18630  " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
18631  "\n"
18632  "\n"
18633  "\n"
18634  "SYNOPSIS:\n"
18635  "\n"
18636  "plptex(x, y, dx, dy, just, text)\n"
18637  "\n"
18638  "ARGUMENTS:\n"
18639  "\n"
18640  " x (PLFLT, input) : x coordinate of reference point of string.\n"
18641  "\n"
18642  " y (PLFLT, input) : y coordinate of reference point of string.\n"
18643  "\n"
18644  " dx (PLFLT, input) : Together with dy, this specifies the\n"
18645  " inclination of the string. The baseline of the string is parallel\n"
18646  " to a line joining (\n"
18647  " x,\n"
18648  " y) to (\n"
18649  " x+\n"
18650  " dx,\n"
18651  " y+\n"
18652  " dy) .\n"
18653  "\n"
18654  " dy (PLFLT, input) : Together with dx, this specifies the\n"
18655  " inclination of the string.\n"
18656  "\n"
18657  " just (PLFLT, input) : Specifies the position of the string relative\n"
18658  " to its reference point. If just=0. , the reference point is at\n"
18659  " the left and if just=1. , it is at the right of the string. Other\n"
18660  " values of just give intermediate justifications.\n"
18661  "\n"
18662  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18663  " written out.\n"
18664  "\n"
18665  ""},
18666  { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
18667  "Write text inside the viewport of a 3D plot\n"
18668  "\n"
18669  "DESCRIPTION:\n"
18670  "\n"
18671  " Writes text at a specified position and inclination and with a\n"
18672  " specified shear within the viewport. Text is clipped at the viewport\n"
18673  " boundaries. The reference point of a string lies along a line passing\n"
18674  " through the string at half the height of a capital letter. The\n"
18675  " position of the reference point along this line is determined by just,\n"
18676  " and the reference point is placed at world coordinates (\n"
18677  " wx,\n"
18678  " wy,\n"
18679  " wz) within the viewport. The inclination and shear of the string is\n"
18680  " specified in terms of differences of world coordinates making it easy\n"
18681  " to write text parallel to a line in a graph.\n"
18682  "\n"
18683  " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18684  "\n"
18685  " This function is used in example 28.\n"
18686  "\n"
18687  "\n"
18688  "\n"
18689  "SYNOPSIS:\n"
18690  "\n"
18691  "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
18692  "\n"
18693  "ARGUMENTS:\n"
18694  "\n"
18695  " wx (PLFLT, input) : x world coordinate of reference point of\n"
18696  " string.\n"
18697  "\n"
18698  " wy (PLFLT, input) : y world coordinate of reference point of\n"
18699  " string.\n"
18700  "\n"
18701  " wz (PLFLT, input) : z world coordinate of reference point of\n"
18702  " string.\n"
18703  "\n"
18704  " dx (PLFLT, input) : Together with dy and\n"
18705  " dz , this specifies the inclination of the string. The baseline of\n"
18706  " the string is parallel to a line joining (\n"
18707  " x,\n"
18708  " y,\n"
18709  " z) to (\n"
18710  " x+\n"
18711  " dx,\n"
18712  " y+\n"
18713  " dy,\n"
18714  " z+\n"
18715  " dz) .\n"
18716  "\n"
18717  " dy (PLFLT, input) : Together with dx and\n"
18718  " dz, this specifies the inclination of the string.\n"
18719  "\n"
18720  " dz (PLFLT, input) : Together with dx and\n"
18721  " dy, this specifies the inclination of the string.\n"
18722  "\n"
18723  " sx (PLFLT, input) : Together with sy and\n"
18724  " sz , this specifies the shear of the string. The string is sheared so\n"
18725  " that the characters are vertically parallel to a line joining (\n"
18726  " x,\n"
18727  " y,\n"
18728  " z) to (\n"
18729  " x+\n"
18730  " sx,\n"
18731  " y+\n"
18732  " sy,\n"
18733  " z+\n"
18734  " sz) . If sx =\n"
18735  " sy =\n"
18736  " sz = 0.) then the text is not sheared.\n"
18737  "\n"
18738  " sy (PLFLT, input) : Together with sx and\n"
18739  " sz, this specifies shear of the string.\n"
18740  "\n"
18741  " sz (PLFLT, input) : Together with sx and\n"
18742  " sy, this specifies shear of the string.\n"
18743  "\n"
18744  " just (PLFLT, input) : Specifies the position of the string relative\n"
18745  " to its reference point. If just=0. , the reference point is at\n"
18746  " the left and if just=1. , it is at the right of the string. Other\n"
18747  " values of just give intermediate justifications.\n"
18748  "\n"
18749  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18750  " written out.\n"
18751  "\n"
18752  ""},
18753  { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
18754  "Random number generator returning a real random number in the range [0,1]\n"
18755  "\n"
18756  "DESCRIPTION:\n"
18757  "\n"
18758  " Random number generator returning a real random number in the range\n"
18759  " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18760  " / compilers provide their own random number generator, and so this is\n"
18761  " provided purely for convenience and to give a consistent random number\n"
18762  " generator across all languages supported by PLplot. This is\n"
18763  " particularly useful for comparing results from the test suite of\n"
18764  " examples.\n"
18765  "\n"
18766  " Redacted form: plrandd()\n"
18767  "\n"
18768  " This function is used in examples 17 and 21.\n"
18769  "\n"
18770  "\n"
18771  "\n"
18772  "SYNOPSIS:\n"
18773  "\n"
18774  "plrandd()\n"
18775  "\n"
18776  ""},
18777  { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
18778  "Replays contents of plot buffer to current device/file\n"
18779  "\n"
18780  "DESCRIPTION:\n"
18781  "\n"
18782  " Replays contents of plot buffer to current device/file.\n"
18783  "\n"
18784  " Redacted form: plreplot()\n"
18785  "\n"
18786  " This function is used in example 1,20.\n"
18787  "\n"
18788  "\n"
18789  "\n"
18790  "SYNOPSIS:\n"
18791  "\n"
18792  "plreplot()\n"
18793  "\n"
18794  ""},
18795  { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
18796  "Convert RGB color to HLS\n"
18797  "\n"
18798  "DESCRIPTION:\n"
18799  "\n"
18800  " Convert RGB color coordinates to HLS\n"
18801  "\n"
18802  " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18803  "\n"
18804  "\n"
18805  " This function is used in example 2.\n"
18806  "\n"
18807  "\n"
18808  "\n"
18809  "SYNOPSIS:\n"
18810  "\n"
18811  "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18812  "\n"
18813  "ARGUMENTS:\n"
18814  "\n"
18815  " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
18816  "\n"
18817  " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
18818  "\n"
18819  " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
18820  "\n"
18821  " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
18822  " degrees (0.0-360.0) on the color cylinder.\n"
18823  "\n"
18824  " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
18825  " expressed as a fraction (0.0-1.0) of the axis of the color\n"
18826  " cylinder.\n"
18827  "\n"
18828  " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
18829  " expressed as a fraction (0.0-1.0) of the radius of the color\n"
18830  " cylinder.\n"
18831  "\n"
18832  ""},
18833  { "plschr", _wrap_plschr, METH_VARARGS, "\n"
18834  "Set character size\n"
18835  "\n"
18836  "DESCRIPTION:\n"
18837  "\n"
18838  " This sets up the size of all subsequent characters drawn. The actual\n"
18839  " height of a character is the product of the default character size and\n"
18840  " a scaling factor.\n"
18841  "\n"
18842  " Redacted form: plschr(def, scale)\n"
18843  "\n"
18844  " This function is used in examples 2, 13, 23, and 24.\n"
18845  "\n"
18846  "\n"
18847  "\n"
18848  "SYNOPSIS:\n"
18849  "\n"
18850  "plschr(def, scale)\n"
18851  "\n"
18852  "ARGUMENTS:\n"
18853  "\n"
18854  " def (PLFLT, input) : The default height of a character in\n"
18855  " millimeters, should be set to zero if the default height is to\n"
18856  " remain unchanged. For rasterized drivers the dx and dy values\n"
18857  " specified in plspage are used to convert from mm to pixels (note\n"
18858  " the different unit systems used). This dpi aware scaling is not\n"
18859  " implemented for all drivers yet.\n"
18860  "\n"
18861  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18862  " actual character height.\n"
18863  "\n"
18864  ""},
18865  { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
18866  "Set cmap0 colors by 8-bit RGB values\n"
18867  "\n"
18868  "DESCRIPTION:\n"
18869  "\n"
18870  " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
18871  " documentation). This sets the entire color map -- only as many colors\n"
18872  " as specified will be allocated.\n"
18873  "\n"
18874  " Redacted form: plscmap0(r, g, b)\n"
18875  "\n"
18876  " This function is used in examples 2 and 24.\n"
18877  "\n"
18878  "\n"
18879  "\n"
18880  "SYNOPSIS:\n"
18881  "\n"
18882  "plscmap0(r, g, b, ncol0)\n"
18883  "\n"
18884  "ARGUMENTS:\n"
18885  "\n"
18886  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18887  " integers (0-255) representing the degree of red in the color.\n"
18888  "\n"
18889  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18890  " integers (0-255) representing the degree of green in the color.\n"
18891  "\n"
18892  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18893  " integers (0-255) representing the degree of blue in the color.\n"
18894  "\n"
18895  " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
18896  "\n"
18897  ""},
18898  { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
18899  "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
18900  "\n"
18901  "DESCRIPTION:\n"
18902  "\n"
18903  " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
18904  " and PLFLT alpha transparency value. This sets the entire color map --\n"
18905  " only as many colors as specified will be allocated.\n"
18906  "\n"
18907  " Redacted form: plscmap0a(r, g, b, alpha)\n"
18908  "\n"
18909  " This function is used in examples 30.\n"
18910  "\n"
18911  "\n"
18912  "\n"
18913  "SYNOPSIS:\n"
18914  "\n"
18915  "plscmap0a(r, g, b, alpha, ncol0)\n"
18916  "\n"
18917  "ARGUMENTS:\n"
18918  "\n"
18919  " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18920  " integers (0-255) representing the degree of red in the color.\n"
18921  "\n"
18922  " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18923  " integers (0-255) representing the degree of green in the color.\n"
18924  "\n"
18925  " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18926  " integers (0-255) representing the degree of blue in the color.\n"
18927  "\n"
18928  " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
18929  " representing the alpha transparency of the color.\n"
18930  "\n"
18931  " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
18932  " vectors.\n"
18933  "\n"
18934  ""},
18935  { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
18936  "Set number of colors in cmap0\n"
18937  "\n"
18938  "DESCRIPTION:\n"
18939  "\n"
18940  " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
18941  " (or reallocate) cmap0, and fill with default values for those colors\n"
18942  " not previously allocated. The first 16 default colors are given in\n"
18943  " the plcol0 documentation. For larger indices the default color is\n"
18944  " red.\n"
18945  "\n"
18946  " The drivers are not guaranteed to support more than 16 colors.\n"
18947  "\n"
18948  " Redacted form: plscmap0n(ncol0)\n"
18949  "\n"
18950  " This function is used in examples 15, 16, and 24.\n"
18951  "\n"
18952  "\n"
18953  "\n"
18954  "SYNOPSIS:\n"
18955  "\n"
18956  "plscmap0n(ncol0)\n"
18957  "\n"
18958  "ARGUMENTS:\n"
18959  "\n"
18960  " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18961  " the cmap0 palette. If this number is zero or less, then the value\n"
18962  " from the previous call to plscmap0n is used and if there is no\n"
18963  " previous call, then a default value is used.\n"
18964  "\n"
18965  ""},
18966  { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
18967  "Set opaque RGB cmap1 colors values\n"
18968  "\n"
18969  "DESCRIPTION:\n"
18970  "\n"
18971  " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
18972  " vector values. This function also sets the number of cmap1 colors.\n"
18973  " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
18974  " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
18975  " plcol1) to an integer index of these RGB vectors in the range from 0\n"
18976  " to\n"
18977  " ncol1-1. So in order for this continuous color model to work\n"
18978  " properly, it is the responsibility of the user of plscmap1 to insure\n"
18979  " that these RGB vectors are continuous functions of their integer\n"
18980  " indices.\n"
18981  "\n"
18982  " Redacted form: plscmap1(r, g, b)\n"
18983  "\n"
18984  " This function is used in example 31.\n"
18985  "\n"
18986  "\n"
18987  "\n"
18988  "SYNOPSIS:\n"
18989  "\n"
18990  "plscmap1(r, g, b, ncol1)\n"
18991  "\n"
18992  "ARGUMENTS:\n"
18993  "\n"
18994  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
18995  " 8-bit integers in the range from 0-255) the degree of red in the\n"
18996  " color as a continuous function of the integer index of the vector.\n"
18997  "\n"
18998  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
18999  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19000  " color as a continuous function of the integer index of the vector.\n"
19001  "\n"
19002  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19003  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19004  " color as a continuous function of the integer index of the vector.\n"
19005  "\n"
19006  " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19007  "\n"
19008  ""},
19009  { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19010  "Set semitransparent cmap1 RGBA colors.\n"
19011  "\n"
19012  "DESCRIPTION:\n"
19013  "\n"
19014  " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19015  " RGBA vector values. This function also sets the number of cmap1\n"
19016  " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19017  " floating-point index in the range from 0.0-1.0 which is linearly\n"
19018  " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19019  " vectors in the range from 0 to\n"
19020  " ncol1-1. So in order for this continuous color model to work\n"
19021  " properly, it is the responsibility of the user of plscmap1 to insure\n"
19022  " that these RGBA vectors are continuous functions of their integer\n"
19023  " indices.\n"
19024  "\n"
19025  " Redacted form: plscmap1a(r, g, b, alpha)\n"
19026  "\n"
19027  " This function is used in example 31.\n"
19028  "\n"
19029  "\n"
19030  "\n"
19031  "SYNOPSIS:\n"
19032  "\n"
19033  "plscmap1a(r, g, b, alpha, ncol1)\n"
19034  "\n"
19035  "ARGUMENTS:\n"
19036  "\n"
19037  " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19038  " 8-bit integers in the range from 0-255) the degree of red in the\n"
19039  " color as a continuous function of the integer index of the vector.\n"
19040  "\n"
19041  " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19042  " 8-bit integers in the range from 0-255) the degree of green in the\n"
19043  " color as a continuous function of the integer index of the vector.\n"
19044  "\n"
19045  " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19046  " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19047  " color as a continuous function of the integer index of the vector.\n"
19048  "\n"
19049  " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19050  " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19051  " completely transparent and 1.0 corresponds to completely opaque)\n"
19052  " the alpha transparency of the color as a continuous function of\n"
19053  " the integer index of the vector.\n"
19054  "\n"
19055  " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19056  " vectors.\n"
19057  "\n"
19058  ""},
19059  { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19060  "Set cmap1 colors using a piece-wise linear relationship\n"
19061  "\n"
19062  "DESCRIPTION:\n"
19063  "\n"
19064  " Set cmap1 colors using a piece-wise linear relationship between the\n"
19065  " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19066  " (see the PLplot documentation). May be called at any time.\n"
19067  "\n"
19068  " The idea here is to specify a number of control points that define the\n"
19069  " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19070  " these points, linear interpolation is used which gives a smooth\n"
19071  " variation of color with intensity index. Any number of control points\n"
19072  " may be specified, located at arbitrary positions, although typically 2\n"
19073  " - 4 are enough. Another way of stating this is that we are traversing\n"
19074  " a given number of lines through HLS or RGB space as we move through\n"
19075  " cmap1 intensity indices. The control points at the minimum and\n"
19076  " maximum position (0 and 1) must always be specified. By adding more\n"
19077  " control points you can get more variation. One good technique for\n"
19078  " plotting functions that vary about some expected average is to use an\n"
19079  " additional 2 control points in the center (position ~= 0.5) that are\n"
19080  " the same lightness as the background (typically white for paper\n"
19081  " output, black for crt), and same hue as the boundary control points.\n"
19082  " This allows the highs and lows to be very easily distinguished.\n"
19083  "\n"
19084  " Each control point must specify the cmap1 intensity index and the\n"
19085  " associated three coordinates in HLS or RGB space. The first point\n"
19086  " must correspond to position = 0, and the last to position = 1.\n"
19087  "\n"
19088  " If RGB colors are provided then the interpolation takes place in RGB\n"
19089  " space and is trivial. However if HLS colors are provided then, because\n"
19090  " of the circular nature of the color wheel for the hue coordinate, the\n"
19091  " interpolation could be performed in either direction around the color\n"
19092  " wheel. The default behaviour is for the hue to be linearly\n"
19093  " interpolated ignoring this circular property of hue. So for example,\n"
19094  " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19095  " green and cyan. If instead you wish to interpolate the other way\n"
19096  " around the color wheel you have two options. You may provide hues\n"
19097  " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19098  " for red the interpolation will proceed via magenta. Alternatively you\n"
19099  " can utilise the alt_hue_path variable to reverse the direction of\n"
19100  " interpolation if you need to provide hues within the [0-360) range.\n"
19101  "\n"
19102  " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19103  " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19104  " -120]falsegreen-yellow-red-magenta-blue[240\n"
19105  " 480]falseblue-magenta-red-yellow-green[120\n"
19106  " 240]truegreen-yellow-red-magenta-blue[240\n"
19107  " 120]trueblue-magenta-red-yellow-green\n"
19108  "\n"
19109  " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19110  " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19111  " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19112  "\n"
19113  " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19114  " alt_hue_path)\n"
19115  "\n"
19116  " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19117  "\n"
19118  "\n"
19119  "\n"
19120  "SYNOPSIS:\n"
19121  "\n"
19122  "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19123  "\n"
19124  "ARGUMENTS:\n"
19125  "\n"
19126  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19127  "\n"
19128  " npts (PLINT, input) : number of control points\n"
19129  "\n"
19130  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19131  " intensity index (0.0-1.0) in ascending order for each control\n"
19132  " point.\n"
19133  "\n"
19134  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19135  " coordinate (H or R) for each control point.\n"
19136  "\n"
19137  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19138  " coordinate (L or G) for each control point.\n"
19139  "\n"
19140  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19141  " coordinate (S or B) for each control point.\n"
19142  "\n"
19143  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19144  " npts - 1 elements), each containing either true to use the reversed\n"
19145  " HLS interpolation or false to use the regular HLS interpolation.\n"
19146  " (alt_hue_path[i] refers to the interpolation interval between the\n"
19147  " i and i + 1 control points). This parameter is not used for RGB\n"
19148  " colors (\n"
19149  " itype = true).\n"
19150  "\n"
19151  ""},
19152  { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19153  "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19154  "\n"
19155  "DESCRIPTION:\n"
19156  "\n"
19157  " This is a variant of plscmap1l that supports alpha channel\n"
19158  " transparency. It sets cmap1 colors using a piece-wise linear\n"
19159  " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19160  " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19161  " transparency value (0.0-1.0). It may be called at any time.\n"
19162  "\n"
19163  " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19164  " alpha, alt_hue_path)\n"
19165  "\n"
19166  " This function is used in example 30.\n"
19167  "\n"
19168  "\n"
19169  "\n"
19170  "SYNOPSIS:\n"
19171  "\n"
19172  "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19173  "\n"
19174  "ARGUMENTS:\n"
19175  "\n"
19176  " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19177  "\n"
19178  " npts (PLINT, input) : number of control points.\n"
19179  "\n"
19180  " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19181  " intensity index (0.0-1.0) in ascending order for each control\n"
19182  " point.\n"
19183  "\n"
19184  " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19185  " coordinate (H or R) for each control point.\n"
19186  "\n"
19187  " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19188  " coordinate (L or G) for each control point.\n"
19189  "\n"
19190  " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19191  " coordinate (S or B) for each control point.\n"
19192  "\n"
19193  " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19194  " transparency value (0.0-1.0) for each control point.\n"
19195  "\n"
19196  " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19197  " npts - 1 elements) containing the alternative interpolation method\n"
19198  " Boolean value for each control point interval. (alt_hue_path[i]\n"
19199  " refers to the interpolation interval between the i and i + 1\n"
19200  " control points).\n"
19201  "\n"
19202  ""},
19203  { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19204  "Set number of colors in cmap1\n"
19205  "\n"
19206  "DESCRIPTION:\n"
19207  "\n"
19208  " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19209  " values if this is the first allocation (see the PLplot documentation).\n"
19210  "\n"
19211  " Redacted form: plscmap1n(ncol1)\n"
19212  "\n"
19213  " This function is used in examples 8, 11, 20, and 21.\n"
19214  "\n"
19215  "\n"
19216  "\n"
19217  "SYNOPSIS:\n"
19218  "\n"
19219  "plscmap1n(ncol1)\n"
19220  "\n"
19221  "ARGUMENTS:\n"
19222  "\n"
19223  " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19224  " the cmap1 palette. If this number is zero or less, then the value\n"
19225  " from the previous call to plscmap1n is used and if there is no\n"
19226  " previous call, then a default value is used.\n"
19227  "\n"
19228  ""},
19229  { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19230  "Set the cmap1 argument range for continuous color plots\n"
19231  "\n"
19232  "DESCRIPTION:\n"
19233  "\n"
19234  " Set the cmap1 argument range for continuous color plots that\n"
19235  " corresponds to the range of data values. The maximum range\n"
19236  " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19237  " the cmap1 argument range that is specified with this routine, the\n"
19238  " smaller the subset of the cmap1 color palette that is used to\n"
19239  " represent the continuous data being plotted. If\n"
19240  " min_color is greater than\n"
19241  " max_color or\n"
19242  " max_color is greater than 1.0 or\n"
19243  " min_color is less than 0.0 then no change is made to the cmap1\n"
19244  " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19245  "\n"
19246  " Redacted form: plscmap1_range(min_color, max_color)\n"
19247  "\n"
19248  " This function is currently used in example 33.\n"
19249  "\n"
19250  "\n"
19251  "\n"
19252  "SYNOPSIS:\n"
19253  "\n"
19254  "plscmap1_range(min_color, max_color)\n"
19255  "\n"
19256  "ARGUMENTS:\n"
19257  "\n"
19258  " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19259  " than 0.0, then 0.0 is used instead.\n"
19260  "\n"
19261  " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19262  " than 1.0, then 1.0 is used instead.\n"
19263  "\n"
19264  ""},
19265  { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
19266  "Get the cmap1 argument range for continuous color plots\n"
19267  "\n"
19268  "DESCRIPTION:\n"
19269  "\n"
19270  " Get the cmap1 argument range for continuous color plots. (Use\n"
19271  " plscmap1_range to set the cmap1 argument range.)\n"
19272  "\n"
19273  " Redacted form: plgcmap1_range(min_color, max_color)\n"
19274  "\n"
19275  " This function is currently not used in any example.\n"
19276  "\n"
19277  "\n"
19278  "\n"
19279  "SYNOPSIS:\n"
19280  "\n"
19281  "plgcmap1_range(min_color, max_color)\n"
19282  "\n"
19283  "ARGUMENTS:\n"
19284  "\n"
19285  " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19286  " minimum cmap1 argument.\n"
19287  "\n"
19288  " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19289  " maximum cmap1 argument.\n"
19290  "\n"
19291  ""},
19292  { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
19293  "Set 8-bit RGB values for given cmap0 color index\n"
19294  "\n"
19295  "DESCRIPTION:\n"
19296  "\n"
19297  " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19298  " index. Overwrites the previous color value for the given index and,\n"
19299  " thus, does not result in any additional allocation of space for\n"
19300  " colors.\n"
19301  "\n"
19302  " Redacted form: plscol0(icol0, r, g, b)\n"
19303  "\n"
19304  " This function is used in any example 31.\n"
19305  "\n"
19306  "\n"
19307  "\n"
19308  "SYNOPSIS:\n"
19309  "\n"
19310  "plscol0(icol0, r, g, b)\n"
19311  "\n"
19312  "ARGUMENTS:\n"
19313  "\n"
19314  " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19315  " number of colors (which is set by default, by plscmap0n, or even\n"
19316  " by plscmap0).\n"
19317  "\n"
19318  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19319  " degree of red in the color.\n"
19320  "\n"
19321  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19322  " degree of green in the color.\n"
19323  "\n"
19324  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19325  " degree of blue in the color.\n"
19326  "\n"
19327  ""},
19328  { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
19329  "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19330  "\n"
19331  "DESCRIPTION:\n"
19332  "\n"
19333  " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19334  " (see the PLplot documentation) index. Overwrites the previous color\n"
19335  " value for the given index and, thus, does not result in any additional\n"
19336  " allocation of space for colors.\n"
19337  "\n"
19338  " This function is used in example 30.\n"
19339  "\n"
19340  "\n"
19341  "\n"
19342  "SYNOPSIS:\n"
19343  "\n"
19344  "plscol0a(icol0, r, g, b, alpha)\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  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19362  " (0.0-1.0).\n"
19363  "\n"
19364  ""},
19365  { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
19366  "Set the background color by 8-bit RGB value\n"
19367  "\n"
19368  "DESCRIPTION:\n"
19369  "\n"
19370  " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19371  " the PLplot documentation).\n"
19372  "\n"
19373  " Redacted form: plscolbg(r, g, b)\n"
19374  "\n"
19375  " This function is used in examples 15 and 31.\n"
19376  "\n"
19377  "\n"
19378  "\n"
19379  "SYNOPSIS:\n"
19380  "\n"
19381  "plscolbg(r, g, b)\n"
19382  "\n"
19383  "ARGUMENTS:\n"
19384  "\n"
19385  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19386  " degree of red in the color.\n"
19387  "\n"
19388  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19389  " degree of green in the color.\n"
19390  "\n"
19391  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19392  " degree of blue in the color.\n"
19393  "\n"
19394  ""},
19395  { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
19396  "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
19397  "\n"
19398  "DESCRIPTION:\n"
19399  "\n"
19400  " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
19401  " PLFLT alpha transparency value (see the PLplot documentation).\n"
19402  "\n"
19403  " This function is used in example 31.\n"
19404  "\n"
19405  "\n"
19406  "\n"
19407  "SYNOPSIS:\n"
19408  "\n"
19409  "plscolbga(r, g, b, alpha)\n"
19410  "\n"
19411  "ARGUMENTS:\n"
19412  "\n"
19413  " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19414  " degree of red in the color.\n"
19415  "\n"
19416  " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19417  " degree of green in the color.\n"
19418  "\n"
19419  " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19420  " degree of blue in the color.\n"
19421  "\n"
19422  " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19423  " (0.0-1.0).\n"
19424  "\n"
19425  ""},
19426  { "plscolor", _wrap_plscolor, METH_O, "\n"
19427  "Used to globally turn color output on/off\n"
19428  "\n"
19429  "DESCRIPTION:\n"
19430  "\n"
19431  " Used to globally turn color output on/off for those drivers/devices\n"
19432  " that support it.\n"
19433  "\n"
19434  " Redacted form: plscolor(color)\n"
19435  "\n"
19436  " This function is used in example 31.\n"
19437  "\n"
19438  "\n"
19439  "\n"
19440  "SYNOPSIS:\n"
19441  "\n"
19442  "plscolor(color)\n"
19443  "\n"
19444  "ARGUMENTS:\n"
19445  "\n"
19446  " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19447  " turned off. If non-zero, color is turned on.\n"
19448  "\n"
19449  ""},
19450  { "plscompression", _wrap_plscompression, METH_O, "\n"
19451  "Set device-compression level\n"
19452  "\n"
19453  "DESCRIPTION:\n"
19454  "\n"
19455  " Set device-compression level. Only used for drivers that provide\n"
19456  " compression. This function, if used, should be invoked before a call\n"
19457  " to plinit.\n"
19458  "\n"
19459  " Redacted form: plscompression(compression)\n"
19460  "\n"
19461  " This function is used in example 31.\n"
19462  "\n"
19463  "\n"
19464  "\n"
19465  "SYNOPSIS:\n"
19466  "\n"
19467  "plscompression(compression)\n"
19468  "\n"
19469  "ARGUMENTS:\n"
19470  "\n"
19471  " compression (PLINT, input) : The desired compression level. This is\n"
19472  " a device-dependent value. Currently only the jpeg and png devices\n"
19473  " use these values. For jpeg value is the jpeg quality which should\n"
19474  " normally be in the range 0-95. Higher values denote higher quality\n"
19475  " and hence larger image sizes. For png values are in the range -1\n"
19476  " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19477  " A value of -1 denotes the default zlib compression level. Values\n"
19478  " in the range 10-99 are divided by 10 and then used as the zlib\n"
19479  " compression level. Higher compression levels correspond to greater\n"
19480  " compression and small file sizes at the expense of more\n"
19481  " computation.\n"
19482  "\n"
19483  ""},
19484  { "plsdev", _wrap_plsdev, METH_O, "\n"
19485  "Set the device (keyword) name\n"
19486  "\n"
19487  "DESCRIPTION:\n"
19488  "\n"
19489  " Set the device (keyword) name.\n"
19490  "\n"
19491  " Redacted form: plsdev(devname)\n"
19492  "\n"
19493  " This function is used in examples 1, 14, and 20.\n"
19494  "\n"
19495  "\n"
19496  "\n"
19497  "SYNOPSIS:\n"
19498  "\n"
19499  "plsdev(devname)\n"
19500  "\n"
19501  "ARGUMENTS:\n"
19502  "\n"
19503  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
19504  " containing the device name keyword of the required output device.\n"
19505  " If\n"
19506  " devname is NULL or if the first character of the string is a ``?'',\n"
19507  " the normal (prompted) start up is used.\n"
19508  "\n"
19509  ""},
19510  { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
19511  "Set parameters that define current device-space window\n"
19512  "\n"
19513  "DESCRIPTION:\n"
19514  "\n"
19515  " Set relative margin width, aspect ratio, and relative justification\n"
19516  " that define current device-space window. If you want to just use the\n"
19517  " previous value for any of these, just pass in the magic value\n"
19518  " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19519  " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19520  " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19521  " to a device-specific value.\n"
19522  "\n"
19523  " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19524  "\n"
19525  " This function is used in example 31.\n"
19526  "\n"
19527  "\n"
19528  "\n"
19529  "SYNOPSIS:\n"
19530  "\n"
19531  "plsdidev(mar, aspect, jx, jy)\n"
19532  "\n"
19533  "ARGUMENTS:\n"
19534  "\n"
19535  " mar (PLFLT, input) : Relative margin width.\n"
19536  "\n"
19537  " aspect (PLFLT, input) : Aspect ratio.\n"
19538  "\n"
19539  " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19540  " the range -0.5 to 0.5.\n"
19541  "\n"
19542  " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19543  " the range -0.5 to 0.5.\n"
19544  "\n"
19545  ""},
19546  { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
19547  "Set up transformation from metafile coordinates\n"
19548  "\n"
19549  "DESCRIPTION:\n"
19550  "\n"
19551  " Set up transformation from metafile coordinates. The size of the plot\n"
19552  " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19553  " general-purpose facility just yet (not sure why the user would need\n"
19554  " it, for one).\n"
19555  "\n"
19556  " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19557  " dimypmm)\n"
19558  "\n"
19559  " This function is not used in any examples.\n"
19560  "\n"
19561  "\n"
19562  "\n"
19563  "SYNOPSIS:\n"
19564  "\n"
19565  "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19566  "\n"
19567  "ARGUMENTS:\n"
19568  "\n"
19569  " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
19570  "\n"
19571  " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
19572  "\n"
19573  " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
19574  "\n"
19575  " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
19576  "\n"
19577  " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19578  "\n"
19579  " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19580  "\n"
19581  ""},
19582  { "plsdiori", _wrap_plsdiori, METH_O, "\n"
19583  "Set plot orientation\n"
19584  "\n"
19585  "DESCRIPTION:\n"
19586  "\n"
19587  " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19588  " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19589  " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19590  " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19591  " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19592  " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19593  " not called the default value of rot is 0.\n"
19594  "\n"
19595  " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19596  " probably want to change the aspect ratio to a value suitable for the\n"
19597  " plot orientation using a call to plsdidev or the command-line options\n"
19598  " -a or -freeaspect. For more documentation of those options see the\n"
19599  " PLplot documentation. Such command-line options can be set internally\n"
19600  " using plsetopt or set directly using the command line and parsed using\n"
19601  " a call to plparseopts.\n"
19602  "\n"
19603  " Redacted form: plsdiori(rot)\n"
19604  "\n"
19605  " This function is not used in any examples.\n"
19606  "\n"
19607  "\n"
19608  "\n"
19609  "SYNOPSIS:\n"
19610  "\n"
19611  "plsdiori(rot)\n"
19612  "\n"
19613  "ARGUMENTS:\n"
19614  "\n"
19615  " rot (PLFLT, input) : Plot orientation parameter.\n"
19616  "\n"
19617  ""},
19618  { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
19619  "Set parameters that define current plot-space window\n"
19620  "\n"
19621  "DESCRIPTION:\n"
19622  "\n"
19623  " Set relative minima and maxima that define the current plot-space\n"
19624  " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19625  " xmax, and ymax are 0., 0., 1., and 1.\n"
19626  "\n"
19627  " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19628  "\n"
19629  " This function is used in example 31.\n"
19630  "\n"
19631  "\n"
19632  "\n"
19633  "SYNOPSIS:\n"
19634  "\n"
19635  "plsdiplt(xmin, ymin, xmax, ymax)\n"
19636  "\n"
19637  "ARGUMENTS:\n"
19638  "\n"
19639  " xmin (PLFLT, input) : Relative minimum in x.\n"
19640  "\n"
19641  " ymin (PLFLT, input) : Relative minimum in y.\n"
19642  "\n"
19643  " xmax (PLFLT, input) : Relative maximum in x.\n"
19644  "\n"
19645  " ymax (PLFLT, input) : Relative maximum in y.\n"
19646  "\n"
19647  ""},
19648  { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
19649  "Set parameters incrementally (zoom mode) that define current plot-space window\n"
19650  "\n"
19651  "DESCRIPTION:\n"
19652  "\n"
19653  " Set relative minima and maxima incrementally (zoom mode) that define\n"
19654  " the current plot-space window. This function has the same effect as\n"
19655  " plsdiplt if that function has not been previously called. Otherwise,\n"
19656  " this function implements zoom mode using the transformation min_used =\n"
19657  " old_min + old_length*min and max_used = old_min + old_length*max for\n"
19658  " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19659  " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
19660  "\n"
19661  " Redacted form: plsdiplz(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  "plsdiplz(xmin, ymin, xmax, ymax)\n"
19670  "\n"
19671  "ARGUMENTS:\n"
19672  "\n"
19673  " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
19674  "\n"
19675  " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
19676  "\n"
19677  " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
19678  "\n"
19679  " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
19680  "\n"
19681  ""},
19682  { "plseed", _wrap_plseed, METH_O, "\n"
19683  "Set seed for internal random number generator.\n"
19684  "\n"
19685  "DESCRIPTION:\n"
19686  "\n"
19687  " Set the seed for the internal random number generator. See plrandd for\n"
19688  " further details.\n"
19689  "\n"
19690  " Redacted form: plseed(seed)\n"
19691  "\n"
19692  " This function is used in example 21.\n"
19693  "\n"
19694  "\n"
19695  "\n"
19696  "SYNOPSIS:\n"
19697  "\n"
19698  "plseed(seed)\n"
19699  "\n"
19700  "ARGUMENTS:\n"
19701  "\n"
19702  " seed (unsigned int, input) : Seed for random number generator.\n"
19703  "\n"
19704  ""},
19705  { "plsesc", _wrap_plsesc, METH_O, "\n"
19706  "Set the escape character for text strings\n"
19707  "\n"
19708  "DESCRIPTION:\n"
19709  "\n"
19710  " Set the escape character for text strings. From C (in contrast to\n"
19711  " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
19712  " characters are allowed to prevent the user from shooting himself in\n"
19713  " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
19714  " use of backslash as a character escape). Here are the allowed escape\n"
19715  " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
19716  " #, ASCII 35\n"
19717  " $, ASCII 36\n"
19718  " %, ASCII 37\n"
19719  " &, ASCII 38\n"
19720  " *, ASCII 42\n"
19721  " @, ASCII 64\n"
19722  " ^, ASCII 94\n"
19723  " ~, ASCII 126\n"
19724  "\n"
19725  "\n"
19726  " Redacted form: General: plsesc(esc)\n"
19727  "\n"
19728  "\n"
19729  " This function is used in example 29.\n"
19730  "\n"
19731  "\n"
19732  "\n"
19733  "SYNOPSIS:\n"
19734  "\n"
19735  "plsesc(esc)\n"
19736  "\n"
19737  "ARGUMENTS:\n"
19738  "\n"
19739  " esc (char, input) : Escape character.\n"
19740  "\n"
19741  ""},
19742  { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
19743  "Set any command-line option\n"
19744  "\n"
19745  "DESCRIPTION:\n"
19746  "\n"
19747  " Set any command-line option internally from a program before it\n"
19748  " invokes plinit. opt is the name of the command-line option and optarg\n"
19749  " is the corresponding command-line option argument.\n"
19750  "\n"
19751  " This function returns 0 on success.\n"
19752  "\n"
19753  " Redacted form: plsetopt(opt, optarg)\n"
19754  "\n"
19755  " This function is used in example 14.\n"
19756  "\n"
19757  "\n"
19758  "\n"
19759  "SYNOPSIS:\n"
19760  "\n"
19761  "PLINT plsetopt(opt, optarg)\n"
19762  "\n"
19763  "ARGUMENTS:\n"
19764  "\n"
19765  " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19766  " the command-line option.\n"
19767  "\n"
19768  " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
19769  " containing the argument of the command-line option.\n"
19770  "\n"
19771  ""},
19772  { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
19773  "Set family file parameters\n"
19774  "\n"
19775  "DESCRIPTION:\n"
19776  "\n"
19777  " Sets variables dealing with output file familying. Does nothing if\n"
19778  " familying not supported by the driver. This routine, if used, must be\n"
19779  " called before initializing PLplot. See the PLplot documentation for\n"
19780  " more information.\n"
19781  "\n"
19782  " Redacted form: plsfam(fam, num, bmax)\n"
19783  "\n"
19784  " This function is used in examples 14 and 31.\n"
19785  "\n"
19786  "\n"
19787  "\n"
19788  "SYNOPSIS:\n"
19789  "\n"
19790  "plsfam(fam, num, bmax)\n"
19791  "\n"
19792  "ARGUMENTS:\n"
19793  "\n"
19794  " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
19795  " is enabled.\n"
19796  "\n"
19797  " num (PLINT, input) : Current family file number.\n"
19798  "\n"
19799  " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19800  " file.\n"
19801  "\n"
19802  ""},
19803  { "plsfci", _wrap_plsfci, METH_O, "\n"
19804  "Set FCI (font characterization integer)\n"
19805  "\n"
19806  "DESCRIPTION:\n"
19807  "\n"
19808  " Sets font characteristics to be used at the start of the next string\n"
19809  " using the FCI approach. See the PLplot documentation for more\n"
19810  " information. Note, plsfont (which calls plsfci internally) provides a\n"
19811  " more user-friendly API for setting the font characterisitics.\n"
19812  "\n"
19813  " Redacted form: General: plsfci(fci)\n"
19814  "\n"
19815  "\n"
19816  " This function is used in example 23.\n"
19817  "\n"
19818  "\n"
19819  "\n"
19820  "SYNOPSIS:\n"
19821  "\n"
19822  "plsfci(fci)\n"
19823  "\n"
19824  "ARGUMENTS:\n"
19825  "\n"
19826  " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19827  " of FCI.\n"
19828  "\n"
19829  ""},
19830  { "plsfnam", _wrap_plsfnam, METH_O, "\n"
19831  "Set output file name\n"
19832  "\n"
19833  "DESCRIPTION:\n"
19834  "\n"
19835  " Sets the current output file name, if applicable. If the file name\n"
19836  " has not been specified and is required by the driver, the user will be\n"
19837  " prompted for it. If using the X-windows output driver, this sets the\n"
19838  " display name. This routine, if used, must be called before\n"
19839  " initializing PLplot.\n"
19840  "\n"
19841  " Redacted form: plsfnam(fnam)\n"
19842  "\n"
19843  " This function is used in examples 1 and 20.\n"
19844  "\n"
19845  "\n"
19846  "\n"
19847  "SYNOPSIS:\n"
19848  "\n"
19849  "plsfnam(fnam)\n"
19850  "\n"
19851  "ARGUMENTS:\n"
19852  "\n"
19853  " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19854  " the file name.\n"
19855  "\n"
19856  ""},
19857  { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
19858  "Set family, style and weight of the current font\n"
19859  "\n"
19860  "DESCRIPTION:\n"
19861  "\n"
19862  " Sets the current font. See the PLplot documentation for more\n"
19863  " information on font selection.\n"
19864  "\n"
19865  " Redacted form: plsfont(family, style, weight)\n"
19866  "\n"
19867  " This function is used in example 23.\n"
19868  "\n"
19869  "\n"
19870  "\n"
19871  "SYNOPSIS:\n"
19872  "\n"
19873  "plsfont(family, style, weight)\n"
19874  "\n"
19875  "ARGUMENTS:\n"
19876  "\n"
19877  " family (PLINT, input) : Font family to select for the current font.\n"
19878  " The available values are given by the PL_FCI_* constants in\n"
19879  " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
19880  " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19881  " signifies that the font family should not be altered.\n"
19882  "\n"
19883  " style (PLINT, input) : Font style to select for the current font.\n"
19884  " The available values are given by the PL_FCI_* constants in\n"
19885  " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19886  " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19887  " should not be altered.\n"
19888  "\n"
19889  " weight (PLINT, input) : Font weight to select for the current font.\n"
19890  " The available values are given by the PL_FCI_* constants in\n"
19891  " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19892  " negative value signifies that the font weight should not be\n"
19893  " altered.\n"
19894  "\n"
19895  ""},
19896  { "plshades", _wrap_plshades, METH_VARARGS, "\n"
19897  "Shade regions on the basis of value\n"
19898  "\n"
19899  "DESCRIPTION:\n"
19900  "\n"
19901  " Shade regions on the basis of value. This is the high-level routine\n"
19902  " for making continuous color shaded plots with cmap1 while plshade\n"
19903  " should be used to plot individual shaded regions using either cmap0 or\n"
19904  " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
19905  " our supported languages.\n"
19906  "\n"
19907  " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19908  " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19909  " pltr_data)\n"
19910  "\n"
19911  "\n"
19912  " This function is used in examples 16, 21, and 22.\n"
19913  "\n"
19914  "\n"
19915  "\n"
19916  "SYNOPSIS:\n"
19917  "\n"
19918  "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19919  "\n"
19920  "ARGUMENTS:\n"
19921  "\n"
19922  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19923  " plot. Should have dimensions of\n"
19924  " nx by\n"
19925  " ny.\n"
19926  "\n"
19927  " nx (PLINT, input) : First dimension of matrix \"a\".\n"
19928  "\n"
19929  " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
19930  "\n"
19931  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
19932  " the region that should be plotted in the shade plot. This\n"
19933  " function accepts x and y coordinates as input arguments and must\n"
19934  " return 1 if the point is to be included in the shade plot and 0\n"
19935  " otherwise. If you want to plot the entire shade plot (the usual\n"
19936  " case), this argument should be set to NULL.\n"
19937  "\n"
19938  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
19939  " pltr below for how these arguments are used (only for the special case\n"
19940  " when the callback function\n"
19941  " pltr is not supplied).\n"
19942  "\n"
19943  " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
19944  " corresponding to the edges of each shaded region that will be\n"
19945  " plotted by this function. To work properly the levels should be\n"
19946  " monotonic.\n"
19947  "\n"
19948  " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19949  " of shade edge values in clevel).\n"
19950  "\n"
19951  " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
19952  " pattern.\n"
19953  "\n"
19954  " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
19955  " contours defining edges of shaded regions. The pen color is only\n"
19956  " temporary set for the contour drawing. Set this value to zero or\n"
19957  " less if no shade edge contours are wanted.\n"
19958  "\n"
19959  " cont_width (PLFLT, input) : Defines line width used for contours\n"
19960  " defining edges of shaded regions. This value may not be honored\n"
19961  " by all drivers. The pen width is only temporary set for the\n"
19962  " contour drawing. Set this value to zero or less if no shade edge\n"
19963  " contours are wanted.\n"
19964  "\n"
19965  " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
19966  " region. Use plfill for this purpose.\n"
19967  "\n"
19968  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
19969  " map to rectangles after coordinate transformation with pltrl.\n"
19970  " Otherwise, set rectangular to false. If rectangular is set to\n"
19971  " true, plshade tries to save time by filling large rectangles.\n"
19972  " This optimization fails if the coordinate transformation distorts\n"
19973  " the shape of rectangles. For example a plot in polar coordinates\n"
19974  " has to have rectangular set to false.\n"
19975  "\n"
19976  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
19977  " defines the transformation between the zero-based indices of the\n"
19978  " matrix a and world coordinates. If\n"
19979  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
19980  " indices of a are mapped to the range\n"
19981  " xmin through\n"
19982  " xmax and the y indices of a are mapped to the range\n"
19983  " ymin through\n"
19984  " ymax.For the C case, transformation functions are provided in the\n"
19985  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
19986  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
19987  " matrices. In addition, C callback routines for the transformation\n"
19988  " can be supplied by the user such as the mypltr function in\n"
19989  " examples/c/x09c.c which provides a general linear transformation\n"
19990  " between index coordinates and world coordinates.For languages\n"
19991  " other than C you should consult the PLplot documentation for the\n"
19992  " details concerning how PLTRANSFORM_callback arguments are\n"
19993  " interfaced. However, in general, a particular pattern of\n"
19994  " callback-associated arguments such as a tr vector with 6 elements;\n"
19995  " xg and yg vectors; or xg and yg matrices are respectively\n"
19996  " interfaced to a linear-transformation routine similar to the above\n"
19997  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
19998  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
19999  " support native language callbacks for handling index to\n"
20000  " world-coordinate transformations. Examples of these various\n"
20001  " approaches are given in examples/<language>x09*,\n"
20002  " examples/<language>x16*, examples/<language>x20*,\n"
20003  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20004  " supported languages.\n"
20005  "\n"
20006  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20007  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20008  " externally supplied.\n"
20009  "\n"
20010  ""},
20011  { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20012  "Shade individual region on the basis of value\n"
20013  "\n"
20014  "DESCRIPTION:\n"
20015  "\n"
20016  " Shade individual region on the basis of value. Use plshades if you\n"
20017  " want to shade a number of contiguous regions using continuous colors.\n"
20018  " In particular the edge contours are treated properly in plshades. If\n"
20019  " you attempt to do contiguous regions with plshade the contours at the\n"
20020  " edge of the shade are partially obliterated by subsequent plots of\n"
20021  " contiguous shaded regions.\n"
20022  "\n"
20023  " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20024  " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20025  " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20026  "\n"
20027  "\n"
20028  " This function is used in example 15.\n"
20029  "\n"
20030  "\n"
20031  "\n"
20032  "SYNOPSIS:\n"
20033  "\n"
20034  "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"
20035  "\n"
20036  "ARGUMENTS:\n"
20037  "\n"
20038  " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20039  " plot. Should have dimensions of\n"
20040  " nx by\n"
20041  " ny.\n"
20042  "\n"
20043  " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20044  "\n"
20045  " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20046  "\n"
20047  " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20048  " the region that should be plotted in the shade plot. This\n"
20049  " function accepts x and y coordinates as input arguments and must\n"
20050  " return 1 if the point is to be included in the shade plot and 0\n"
20051  " otherwise. If you want to plot the entire shade plot (the usual\n"
20052  " case), this argument should be set to NULL.\n"
20053  "\n"
20054  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20055  " pltr below for how these arguments are used (only for the special case\n"
20056  " when the callback function\n"
20057  " pltr is not supplied).\n"
20058  "\n"
20059  " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20060  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20061  "\n"
20062  " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20063  " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20064  "\n"
20065  " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20066  " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20067  " then sh_color is interpreted as a cmap1 argument in the range\n"
20068  " (0.0-1.0).\n"
20069  "\n"
20070  " sh_color (PLFLT, input) : Defines color map index with integer\n"
20071  " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20072  "\n"
20073  " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20074  "\n"
20075  " min_color (PLINT, input) : Defines pen color, width used by the\n"
20076  " boundary of shaded region. The min values are used for the\n"
20077  " shade_min boundary, and the max values are used on the shade_max\n"
20078  " boundary. Set color and width to zero for no plotted boundaries.\n"
20079  "\n"
20080  " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20081  " boundary of shaded region. The min values are used for the\n"
20082  " shade_min boundary, and the max values are used on the shade_max\n"
20083  " boundary. Set color and width to zero for no plotted boundaries.\n"
20084  "\n"
20085  " max_color (PLINT, input) : Defines pen color, width used by the\n"
20086  " boundary of shaded region. The min values are used for the\n"
20087  " shade_min boundary, and the max values are used on the shade_max\n"
20088  " boundary. Set color and width to zero for no plotted boundaries.\n"
20089  "\n"
20090  " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20091  " boundary of shaded region. The min values are used for the\n"
20092  " shade_min boundary, and the max values are used on the shade_max\n"
20093  " boundary. Set color and width to zero for no plotted boundaries.\n"
20094  "\n"
20095  " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20096  " Use plfill. Future version of PLplot may have other fill\n"
20097  " routines.\n"
20098  "\n"
20099  " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20100  " map to rectangles after coordinate transformation with pltrl.\n"
20101  " Otherwise, set rectangular to false. If rectangular is set to\n"
20102  " true, plshade tries to save time by filling large rectangles.\n"
20103  " This optimization fails if the coordinate transformation distorts\n"
20104  " the shape of rectangles. For example a plot in polar coordinates\n"
20105  " has to have rectangular set to false.\n"
20106  "\n"
20107  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20108  " defines the transformation between the zero-based indices of the\n"
20109  " matrix a and world coordinates. If\n"
20110  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20111  " indices of a are mapped to the range\n"
20112  " xmin through\n"
20113  " xmax and the y indices of a are mapped to the range\n"
20114  " ymin through\n"
20115  " ymax.For the C case, transformation functions are provided in the\n"
20116  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20117  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20118  " matrices. In addition, C callback routines for the transformation\n"
20119  " can be supplied by the user such as the mypltr function in\n"
20120  " examples/c/x09c.c which provides a general linear transformation\n"
20121  " between index coordinates and world coordinates.For languages\n"
20122  " other than C you should consult the PLplot documentation for the\n"
20123  " details concerning how PLTRANSFORM_callback arguments are\n"
20124  " interfaced. However, in general, a particular pattern of\n"
20125  " callback-associated arguments such as a tr vector with 6 elements;\n"
20126  " xg and yg vectors; or xg and yg matrices are respectively\n"
20127  " interfaced to a linear-transformation routine similar to the above\n"
20128  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20129  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20130  " support native language callbacks for handling index to\n"
20131  " world-coordinate transformations. Examples of these various\n"
20132  " approaches are given in examples/<language>x09*,\n"
20133  " examples/<language>x16*, examples/<language>x20*,\n"
20134  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20135  " supported languages.\n"
20136  "\n"
20137  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20138  " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20139  " externally supplied.\n"
20140  "\n"
20141  ""},
20142  { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20143  "Assign a function to use for generating custom axis labels\n"
20144  "\n"
20145  "DESCRIPTION:\n"
20146  "\n"
20147  " This function allows a user to provide their own function to provide\n"
20148  " axis label text. The user function is given the numeric value for a\n"
20149  " point on an axis and returns a string label to correspond with that\n"
20150  " value. Custom axis labels can be enabled by passing appropriate\n"
20151  " arguments to plenv, plbox, plbox3 and similar functions.\n"
20152  "\n"
20153  " This function is used in example 19.\n"
20154  "\n"
20155  "\n"
20156  "\n"
20157  "SYNOPSIS:\n"
20158  "\n"
20159  "plslabelfunc(label_func, label_data)\n"
20160  "\n"
20161  "ARGUMENTS:\n"
20162  "\n"
20163  " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20164  " label function. In order to reset to the default labelling, set\n"
20165  " this to NULL. The labelling function parameters are, in order:\n"
20166  " axis: This indicates which axis a label is being requested for.\n"
20167  " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20168  "\n"
20169  " value: This is the value along the axis which is being labelled.\n"
20170  "\n"
20171  " label_text: The string representation of the label value.\n"
20172  "\n"
20173  " length: The maximum length in characters allowed for label_text.\n"
20174  "\n"
20175  "\n"
20176  " label_data (PLPointer, input) : This parameter may be used to pass\n"
20177  " data to the label_func function.\n"
20178  "\n"
20179  ""},
20180  { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20181  "Set length of major ticks\n"
20182  "\n"
20183  "DESCRIPTION:\n"
20184  "\n"
20185  " This sets up the length of the major ticks. The actual length is the\n"
20186  " product of the default length and a scaling factor as for character\n"
20187  " height.\n"
20188  "\n"
20189  " Redacted form: plsmaj(def, scale)\n"
20190  "\n"
20191  " This function is used in example 29.\n"
20192  "\n"
20193  "\n"
20194  "\n"
20195  "SYNOPSIS:\n"
20196  "\n"
20197  "plsmaj(def, scale)\n"
20198  "\n"
20199  "ARGUMENTS:\n"
20200  "\n"
20201  " def (PLFLT, input) : The default length of a major tick in\n"
20202  " millimeters, should be set to zero if the default length is to\n"
20203  " remain unchanged.\n"
20204  "\n"
20205  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20206  " actual tick length.\n"
20207  "\n"
20208  ""},
20209  { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20210  "Set the memory area to be plotted (RGB)\n"
20211  "\n"
20212  "DESCRIPTION:\n"
20213  "\n"
20214  " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20215  " the dev member of the stream structure. Also set the number of pixels\n"
20216  " in the memory passed in\n"
20217  " plotmem, which is a block of memory\n"
20218  " maxy by\n"
20219  " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20220  "\n"
20221  " This memory will have to be freed by the user!\n"
20222  "\n"
20223  " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20224  "\n"
20225  " This function is not used in any examples.\n"
20226  "\n"
20227  "\n"
20228  "\n"
20229  "SYNOPSIS:\n"
20230  "\n"
20231  "plsmem(maxx, maxy, plotmem)\n"
20232  "\n"
20233  "ARGUMENTS:\n"
20234  "\n"
20235  " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20236  "\n"
20237  " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20238  "\n"
20239  " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20240  " user-supplied writeable memory area.\n"
20241  "\n"
20242  ""},
20243  { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20244  "Set the memory area to be plotted (RGBA)\n"
20245  "\n"
20246  "DESCRIPTION:\n"
20247  "\n"
20248  " Set the memory area to be plotted (with the memcairo driver) as the\n"
20249  " dev member of the stream structure. Also set the number of pixels in\n"
20250  " the memory passed in\n"
20251  " plotmem, which is a block of memory\n"
20252  " maxy by\n"
20253  " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20254  "\n"
20255  " This memory will have to be freed by the user!\n"
20256  "\n"
20257  " Redacted form: plsmema(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  "plsmema(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  { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
20278  "Set length of minor ticks\n"
20279  "\n"
20280  "DESCRIPTION:\n"
20281  "\n"
20282  " This sets up the length of the minor ticks and the length of the\n"
20283  " terminals on error bars. The actual length is the product of the\n"
20284  " default length and a scaling factor as for character height.\n"
20285  "\n"
20286  " Redacted form: plsmin(def, scale)\n"
20287  "\n"
20288  " This function is used in example 29.\n"
20289  "\n"
20290  "\n"
20291  "\n"
20292  "SYNOPSIS:\n"
20293  "\n"
20294  "plsmin(def, scale)\n"
20295  "\n"
20296  "ARGUMENTS:\n"
20297  "\n"
20298  " def (PLFLT, input) : The default length of a minor tick in\n"
20299  " millimeters, should be set to zero if the default length is to\n"
20300  " remain unchanged.\n"
20301  "\n"
20302  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20303  " actual tick length.\n"
20304  "\n"
20305  ""},
20306  { "plsori", _wrap_plsori, METH_O, "\n"
20307  "Set orientation\n"
20308  "\n"
20309  "DESCRIPTION:\n"
20310  "\n"
20311  " Set integer plot orientation parameter. This function is identical to\n"
20312  " plsdiori except for the type of the argument, and should be used in\n"
20313  " the same way. See the documentation of plsdiori for details.\n"
20314  "\n"
20315  " Redacted form: plsori(ori)\n"
20316  "\n"
20317  " This function is used in example 3.\n"
20318  "\n"
20319  "\n"
20320  "\n"
20321  "SYNOPSIS:\n"
20322  "\n"
20323  "plsori(ori)\n"
20324  "\n"
20325  "ARGUMENTS:\n"
20326  "\n"
20327  " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20328  " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20329  " angle.\n"
20330  "\n"
20331  ""},
20332  { "plspage", _wrap_plspage, METH_VARARGS, "\n"
20333  "Set page parameters\n"
20334  "\n"
20335  "DESCRIPTION:\n"
20336  "\n"
20337  " Sets the page configuration (optional). If an individual parameter is\n"
20338  " zero then that parameter value is not updated. Not all parameters are\n"
20339  " recognized by all drivers and the interpretation is device-dependent.\n"
20340  " The X-window driver uses the length and offset parameters to determine\n"
20341  " the window size and location. The length and offset values are\n"
20342  " expressed in units that are specific to the current driver. For\n"
20343  " instance: screen drivers will usually interpret them as number of\n"
20344  " pixels, whereas printer drivers will usually use mm.\n"
20345  "\n"
20346  " This routine, if used, must be called before initializing PLplot. It\n"
20347  " may be called at later times for interactive drivers to change only\n"
20348  " the dpi for subsequent redraws which you can force via a call to\n"
20349  " plreplot. If this function is not called then the page size defaults\n"
20350  " to landscape A4 for drivers which use real world page sizes and 744\n"
20351  " pixels wide by 538 pixels high for raster drivers. The default value\n"
20352  " for dx and dy is 90 pixels per inch for raster drivers.\n"
20353  "\n"
20354  "\n"
20355  "\n"
20356  " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20357  "\n"
20358  " This function is used in examples 14 and 31.\n"
20359  "\n"
20360  "\n"
20361  "\n"
20362  "SYNOPSIS:\n"
20363  "\n"
20364  "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20365  "\n"
20366  "ARGUMENTS:\n"
20367  "\n"
20368  " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20369  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20370  " (e.g. mm).\n"
20371  "\n"
20372  " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20373  " by raster drivers, ignored by drivers which use \"real world\" units\n"
20374  " (e.g. mm).\n"
20375  "\n"
20376  " xleng (PLINT, input) : Page length, x.\n"
20377  "\n"
20378  " yleng (PLINT, input) : Page length, y.\n"
20379  "\n"
20380  " xoff (PLINT, input) : Page offset, x.\n"
20381  "\n"
20382  " yoff (PLINT, input) : Page offset, y.\n"
20383  "\n"
20384  ""},
20385  { "plspal0", _wrap_plspal0, METH_O, "\n"
20386  "Set the cmap0 palette using the specified cmap0*.pal format file\n"
20387  "\n"
20388  "DESCRIPTION:\n"
20389  "\n"
20390  " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
20391  "\n"
20392  " Redacted form: plspal0(filename)\n"
20393  "\n"
20394  " This function is in example 16.\n"
20395  "\n"
20396  "\n"
20397  "\n"
20398  "SYNOPSIS:\n"
20399  "\n"
20400  "plspal0(filename)\n"
20401  "\n"
20402  "ARGUMENTS:\n"
20403  "\n"
20404  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20405  " containing the name of the cmap0*.pal file. If this string is\n"
20406  " empty, use the default cmap0*.pal file.\n"
20407  "\n"
20408  ""},
20409  { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
20410  "Set the cmap1 palette using the specified cmap1*.pal format file\n"
20411  "\n"
20412  "DESCRIPTION:\n"
20413  "\n"
20414  " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
20415  "\n"
20416  " Redacted form: plspal1(filename, interpolate)\n"
20417  "\n"
20418  " This function is used in example 16.\n"
20419  "\n"
20420  "\n"
20421  "\n"
20422  "SYNOPSIS:\n"
20423  "\n"
20424  "plspal1(filename, interpolate)\n"
20425  "\n"
20426  "ARGUMENTS:\n"
20427  "\n"
20428  " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20429  " containing the name of the cmap1*.pal file. If this string is\n"
20430  " empty, use the default cmap1*.pal file.\n"
20431  "\n"
20432  " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20433  " columns containing the intensity index, r, g, b, alpha and\n"
20434  " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20435  " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20436  " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20437  " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20438  " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20439  " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20440  " are used instead to set the cmap1 palette directly with a call to\n"
20441  " plscmap1a.\n"
20442  "\n"
20443  ""},
20444  { "plspause", _wrap_plspause, METH_O, "\n"
20445  "Set the pause (on end-of-page) status\n"
20446  "\n"
20447  "DESCRIPTION:\n"
20448  "\n"
20449  " Set the pause (on end-of-page) status.\n"
20450  "\n"
20451  " Redacted form: plspause(pause)\n"
20452  "\n"
20453  " This function is in examples 14,20.\n"
20454  "\n"
20455  "\n"
20456  "\n"
20457  "SYNOPSIS:\n"
20458  "\n"
20459  "plspause(pause)\n"
20460  "\n"
20461  "ARGUMENTS:\n"
20462  "\n"
20463  " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20464  " end-of-page for those drivers which support this. Otherwise there\n"
20465  " is no pause.\n"
20466  "\n"
20467  ""},
20468  { "plsstrm", _wrap_plsstrm, METH_O, "\n"
20469  "Set current output stream\n"
20470  "\n"
20471  "DESCRIPTION:\n"
20472  "\n"
20473  " Sets the number of the current output stream. The stream number\n"
20474  " defaults to 0 unless changed by this routine. The first use of this\n"
20475  " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
20476  "\n"
20477  " Redacted form: plsstrm(strm)\n"
20478  "\n"
20479  " This function is examples 1,14,20.\n"
20480  "\n"
20481  "\n"
20482  "\n"
20483  "SYNOPSIS:\n"
20484  "\n"
20485  "plsstrm(strm)\n"
20486  "\n"
20487  "ARGUMENTS:\n"
20488  "\n"
20489  " strm (PLINT, input) : The current stream number.\n"
20490  "\n"
20491  ""},
20492  { "plssub", _wrap_plssub, METH_VARARGS, "\n"
20493  "Set the number of subpages in x and y\n"
20494  "\n"
20495  "DESCRIPTION:\n"
20496  "\n"
20497  " Set the number of subpages in x and y.\n"
20498  "\n"
20499  " Redacted form: plssub(nx, ny)\n"
20500  "\n"
20501  " This function is examples 1,2,14,21,25,27.\n"
20502  "\n"
20503  "\n"
20504  "\n"
20505  "SYNOPSIS:\n"
20506  "\n"
20507  "plssub(nx, ny)\n"
20508  "\n"
20509  "ARGUMENTS:\n"
20510  "\n"
20511  " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20512  " of window columns).\n"
20513  "\n"
20514  " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20515  " of window rows).\n"
20516  "\n"
20517  ""},
20518  { "plssym", _wrap_plssym, METH_VARARGS, "\n"
20519  "Set symbol size\n"
20520  "\n"
20521  "DESCRIPTION:\n"
20522  "\n"
20523  " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20524  " plsym. The actual height of a symbol is the product of the default\n"
20525  " symbol size and a scaling factor as for the character height.\n"
20526  "\n"
20527  " Redacted form: plssym(def, scale)\n"
20528  "\n"
20529  " This function is used in example 29.\n"
20530  "\n"
20531  "\n"
20532  "\n"
20533  "SYNOPSIS:\n"
20534  "\n"
20535  "plssym(def, scale)\n"
20536  "\n"
20537  "ARGUMENTS:\n"
20538  "\n"
20539  " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20540  " should be set to zero if the default height is to remain\n"
20541  " unchanged.\n"
20542  "\n"
20543  " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20544  " actual symbol height.\n"
20545  "\n"
20546  ""},
20547  { "plstar", _wrap_plstar, METH_VARARGS, "\n"
20548  "Initialization\n"
20549  "\n"
20550  "DESCRIPTION:\n"
20551  "\n"
20552  " Initializing the plotting package. The program prompts for the device\n"
20553  " keyword or number of the desired output device. Hitting a RETURN in\n"
20554  " response to the prompt is the same as selecting the first device. If\n"
20555  " only one device is enabled when PLplot is installed, plstar will issue\n"
20556  " no prompt. The output device is divided into nx by ny subpages, each\n"
20557  " of which may be used independently. The subroutine pladv is used to\n"
20558  " advance from one subpage to the next.\n"
20559  "\n"
20560  " Redacted form: plstar(nx, ny)\n"
20561  "\n"
20562  " This function is used in example 1.\n"
20563  "\n"
20564  "\n"
20565  "\n"
20566  "SYNOPSIS:\n"
20567  "\n"
20568  "plstar(nx, ny)\n"
20569  "\n"
20570  "ARGUMENTS:\n"
20571  "\n"
20572  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20573  " x direction.\n"
20574  "\n"
20575  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20576  " y direction.\n"
20577  "\n"
20578  ""},
20579  { "plstart", _wrap_plstart, METH_VARARGS, "\n"
20580  "Initialization\n"
20581  "\n"
20582  "DESCRIPTION:\n"
20583  "\n"
20584  " Alternative to plstar for initializing the plotting package. The\n"
20585  " device name keyword for the desired output device must be supplied as\n"
20586  " an argument. These keywords are the same as those printed out by\n"
20587  " plstar. If the requested device is not available, or if the input\n"
20588  " string is empty or begins with ``?'', the prompted start up of plstar\n"
20589  " is used. This routine also divides the output device page into nx by\n"
20590  " ny subpages, each of which may be used independently. The subroutine\n"
20591  " pladv is used to advance from one subpage to the next.\n"
20592  "\n"
20593  " Redacted form: General: plstart(devname, nx, ny)\n"
20594  "\n"
20595  "\n"
20596  " This function is not used in any examples.\n"
20597  "\n"
20598  "\n"
20599  "\n"
20600  "SYNOPSIS:\n"
20601  "\n"
20602  "plstart(devname, nx, ny)\n"
20603  "\n"
20604  "ARGUMENTS:\n"
20605  "\n"
20606  " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20607  " containing the device name keyword of the required output device.\n"
20608  " If\n"
20609  " devname is NULL or if the first character of the string is a ``?'',\n"
20610  " the normal (prompted) start up is used.\n"
20611  "\n"
20612  " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20613  " x direction.\n"
20614  "\n"
20615  " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20616  " y direction.\n"
20617  "\n"
20618  ""},
20619  { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
20620  "Set a global coordinate transform function\n"
20621  "\n"
20622  "DESCRIPTION:\n"
20623  "\n"
20624  " This function can be used to define a coordinate transformation which\n"
20625  " affects all elements drawn within the current plot window. The\n"
20626  " coordinate_transform callback function is similar to that provided for\n"
20627  " the plmap and plmeridians functions. The coordinate_transform_data\n"
20628  " parameter may be used to pass extra data to coordinate_transform.\n"
20629  "\n"
20630  " Redacted form: General: plstransform(coordinate_transform,\n"
20631  " coordinate_transform_data)\n"
20632  "\n"
20633  "\n"
20634  " This function is used in examples 19 and 22.\n"
20635  "\n"
20636  "\n"
20637  "\n"
20638  "SYNOPSIS:\n"
20639  "\n"
20640  "plstransform(coordinate_transform, coordinate_transform_data)\n"
20641  "\n"
20642  "ARGUMENTS:\n"
20643  "\n"
20644  " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
20645  " function that defines the transformation from the input (x, y)\n"
20646  " world coordinates to new PLplot world coordinates. If\n"
20647  " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
20648  " case), then no transform is applied.\n"
20649  "\n"
20650  " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
20651  " for\n"
20652  " coordinate_transform.\n"
20653  "\n"
20654  ""},
20655  { "plstring", _wrap_plstring, METH_VARARGS, "\n"
20656  "Plot a glyph at the specified points\n"
20657  "\n"
20658  "DESCRIPTION:\n"
20659  "\n"
20660  " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20661  " because many[!] more glyphs are accessible with plstring.) The glyph\n"
20662  " is specified with a PLplot user string. Note that the user string is\n"
20663  " not actually limited to one glyph so it is possible (but not normally\n"
20664  " useful) to plot more than one glyph at the specified points with this\n"
20665  " function. As with plmtex and plptex, the user string can contain FCI\n"
20666  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20667  " else PLplot escapes for Hershey or unicode text to determine the\n"
20668  " glyph.\n"
20669  "\n"
20670  " Redacted form: plstring(x, y, string)\n"
20671  "\n"
20672  " This function is used in examples 4, 21 and 26.\n"
20673  "\n"
20674  "\n"
20675  "\n"
20676  "SYNOPSIS:\n"
20677  "\n"
20678  "plstring(n, x, y, string)\n"
20679  "\n"
20680  "ARGUMENTS:\n"
20681  "\n"
20682  " n (PLINT, input) : Number of points in the x and y vectors.\n"
20683  "\n"
20684  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20685  " the points.\n"
20686  "\n"
20687  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20688  " the points.\n"
20689  "\n"
20690  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20691  " the glyph(s) to be plotted at each of the n points.\n"
20692  "\n"
20693  ""},
20694  { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
20695  "Plot a glyph at the specified 3D points\n"
20696  "\n"
20697  "DESCRIPTION:\n"
20698  "\n"
20699  " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20700  " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20701  " this function similar to what is done for plline3. The glyph is\n"
20702  " specified with a PLplot user string. Note that the user string is not\n"
20703  " actually limited to one glyph so it is possible (but not normally\n"
20704  " useful) to plot more than one glyph at the specified points with this\n"
20705  " function. As with plmtex and plptex, the user string can contain FCI\n"
20706  " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20707  " else PLplot escapes for Hershey or unicode text to determine the\n"
20708  " glyph.\n"
20709  "\n"
20710  " Redacted form: plstring3(x, y, z, string)\n"
20711  "\n"
20712  " This function is used in example 18.\n"
20713  "\n"
20714  "\n"
20715  "\n"
20716  "SYNOPSIS:\n"
20717  "\n"
20718  "plstring3(n, x, y, z, string)\n"
20719  "\n"
20720  "ARGUMENTS:\n"
20721  "\n"
20722  " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
20723  "\n"
20724  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20725  " the points.\n"
20726  "\n"
20727  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20728  " the points.\n"
20729  "\n"
20730  " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
20731  " the points.\n"
20732  "\n"
20733  " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20734  " the glyph(s) to be plotted at each of the n points. points.\n"
20735  "\n"
20736  ""},
20737  { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
20738  "Add a point to a strip chart\n"
20739  "\n"
20740  "DESCRIPTION:\n"
20741  "\n"
20742  " Add a point to a given pen of a given strip chart. There is no need\n"
20743  " for all pens to have the same number of points or to be equally\n"
20744  " sampled in the x coordinate. Allocates memory and rescales as\n"
20745  " necessary.\n"
20746  "\n"
20747  " Redacted form: plstripa(id, pen, x, y)\n"
20748  "\n"
20749  " This function is used in example 17.\n"
20750  "\n"
20751  "\n"
20752  "\n"
20753  "SYNOPSIS:\n"
20754  "\n"
20755  "plstripa(id, pen, x, y)\n"
20756  "\n"
20757  "ARGUMENTS:\n"
20758  "\n"
20759  " id (PLINT, input) : Identification number of the strip chart (set\n"
20760  " up in plstripc).\n"
20761  "\n"
20762  " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
20763  "\n"
20764  " x (PLFLT, input) : X coordinate of point to plot.\n"
20765  "\n"
20766  " y (PLFLT, input) : Y coordinate of point to plot.\n"
20767  "\n"
20768  ""},
20769  { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
20770  "Create a 4-pen strip chart\n"
20771  "\n"
20772  "DESCRIPTION:\n"
20773  "\n"
20774  " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20775  "\n"
20776  " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20777  " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20778  " styline, legline, labx, laby, labz)\n"
20779  "\n"
20780  "\n"
20781  " This function is used in example 17.\n"
20782  "\n"
20783  "\n"
20784  "\n"
20785  "SYNOPSIS:\n"
20786  "\n"
20787  "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20788  "\n"
20789  "ARGUMENTS:\n"
20790  "\n"
20791  " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
20792  " number of the strip chart to use on plstripa and plstripd.\n"
20793  "\n"
20794  " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20795  " the x-axis specification as in plbox.\n"
20796  "\n"
20797  " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20798  " the y-axis specification as in plbox.\n"
20799  "\n"
20800  " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20801  " change as data are added.\n"
20802  "\n"
20803  " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20804  " change as data are added.\n"
20805  "\n"
20806  " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
20807  " is multiplied by the factor (1 +\n"
20808  " xjump) .\n"
20809  "\n"
20810  " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20811  " change as data are added.\n"
20812  "\n"
20813  " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20814  " change as data are added.\n"
20815  "\n"
20816  " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
20817  "\n"
20818  " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
20819  "\n"
20820  " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
20821  " true, otherwise not.\n"
20822  "\n"
20823  " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
20824  " otherwise slide display.\n"
20825  "\n"
20826  " colbox (PLINT, input) : Plot box color index (cmap0).\n"
20827  "\n"
20828  " collab (PLINT, input) : Legend color index (cmap0).\n"
20829  "\n"
20830  " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
20831  " indices for the 4 pens.\n"
20832  "\n"
20833  " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
20834  " indices for the 4 pens.\n"
20835  "\n"
20836  " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
20837  " strings containing legends for the 4 pens.\n"
20838  "\n"
20839  " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20840  " the label for the x axis.\n"
20841  "\n"
20842  " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20843  " the label for the y axis.\n"
20844  "\n"
20845  " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20846  " the plot title.\n"
20847  "\n"
20848  ""},
20849  { "plstripd", _wrap_plstripd, METH_O, "\n"
20850  "Deletes and releases memory used by a strip chart\n"
20851  "\n"
20852  "DESCRIPTION:\n"
20853  "\n"
20854  " Deletes and releases memory used by a strip chart.\n"
20855  "\n"
20856  " Redacted form: plstripd(id)\n"
20857  "\n"
20858  " This function is used in example 17.\n"
20859  "\n"
20860  "\n"
20861  "\n"
20862  "SYNOPSIS:\n"
20863  "\n"
20864  "plstripd(id)\n"
20865  "\n"
20866  "ARGUMENTS:\n"
20867  "\n"
20868  " id (PLINT, input) : Identification number of strip chart to delete.\n"
20869  "\n"
20870  ""},
20871  { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
20872  "Set line style\n"
20873  "\n"
20874  "DESCRIPTION:\n"
20875  "\n"
20876  " This sets up the line style for all lines subsequently drawn. A line\n"
20877  " consists of segments in which the pen is alternately down and up. The\n"
20878  " lengths of these segments are passed in the vectors mark and space\n"
20879  " respectively. The number of mark-space pairs is specified by nms. In\n"
20880  " order to return the line style to the default continuous line, plstyl\n"
20881  " should be called with nms =0 .(see also pllsty)\n"
20882  "\n"
20883  " Redacted form: plstyl(mark, space)\n"
20884  "\n"
20885  " This function is used in examples 1, 9, and 14.\n"
20886  "\n"
20887  "\n"
20888  "\n"
20889  "SYNOPSIS:\n"
20890  "\n"
20891  "plstyl(nms, mark, space)\n"
20892  "\n"
20893  "ARGUMENTS:\n"
20894  "\n"
20895  " nms (PLINT, input) : The number of mark and space elements in a\n"
20896  " line. Thus a simple broken line can be obtained by setting nms=1\n"
20897  " . A continuous line is specified by setting nms=0 .\n"
20898  "\n"
20899  " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
20900  " segments during which the pen is down, measured in micrometers.\n"
20901  "\n"
20902  " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
20903  " the segments during which the pen is up, measured in micrometers.\n"
20904  "\n"
20905  ""},
20906  { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
20907  "Set arrow style for vector plots\n"
20908  "\n"
20909  "DESCRIPTION:\n"
20910  "\n"
20911  " Set the style for the arrow used by plvect to plot vectors.\n"
20912  "\n"
20913  " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20914  "\n"
20915  " This function is used in example 22.\n"
20916  "\n"
20917  "\n"
20918  "\n"
20919  "SYNOPSIS:\n"
20920  "\n"
20921  "plsvect(arrowx, arrowy, npts, fill)\n"
20922  "\n"
20923  "ARGUMENTS:\n"
20924  "\n"
20925  " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
20926  " the x and y points which make up the arrow. The arrow is plotted\n"
20927  " by joining these points to form a polygon. The scaling assumes\n"
20928  " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
20929  " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
20930  " will be reset to its default.\n"
20931  "\n"
20932  " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
20933  " arrowy.\n"
20934  "\n"
20935  " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
20936  " fill is false then the arrow is open.\n"
20937  "\n"
20938  ""},
20939  { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
20940  "Specify viewport in absolute coordinates\n"
20941  "\n"
20942  "DESCRIPTION:\n"
20943  "\n"
20944  " Alternate routine to plvpor for setting up the viewport. This routine\n"
20945  " should be used only if the viewport is required to have a definite\n"
20946  " size in millimeters. The routine plgspa is useful for finding out the\n"
20947  " size of the current subpage.\n"
20948  "\n"
20949  " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20950  "\n"
20951  " This function is used in example 10.\n"
20952  "\n"
20953  "\n"
20954  "\n"
20955  "SYNOPSIS:\n"
20956  "\n"
20957  "plsvpa(xmin, xmax, ymin, ymax)\n"
20958  "\n"
20959  "ARGUMENTS:\n"
20960  "\n"
20961  " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20962  " viewport from the left-hand edge of the subpage in millimeters.\n"
20963  "\n"
20964  " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20965  " viewport from the left-hand edge of the subpage in millimeters.\n"
20966  "\n"
20967  " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
20968  " viewport from the bottom edge of the subpage in millimeters.\n"
20969  "\n"
20970  " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
20971  " from the bottom edge of the subpage in millimeters.\n"
20972  "\n"
20973  ""},
20974  { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
20975  "Set x axis parameters\n"
20976  "\n"
20977  "DESCRIPTION:\n"
20978  "\n"
20979  " Sets values of the digmax and digits flags for the x axis. See the\n"
20980  " PLplot documentation for more information.\n"
20981  "\n"
20982  " Redacted form: plsxax(digmax, digits)\n"
20983  "\n"
20984  " This function is used in example 31.\n"
20985  "\n"
20986  "\n"
20987  "\n"
20988  "SYNOPSIS:\n"
20989  "\n"
20990  "plsxax(digmax, digits)\n"
20991  "\n"
20992  "ARGUMENTS:\n"
20993  "\n"
20994  " digmax (PLINT, input) : Variable to set the maximum number of\n"
20995  " digits for the x axis. If nonzero, the printed label will be\n"
20996  " switched to a floating-point representation when the number of\n"
20997  " digits exceeds digmax.\n"
20998  "\n"
20999  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21000  " its value here has no effect since it is set only by plbox or\n"
21001  " plbox3. However, the user may obtain its value after a call to\n"
21002  " either of these functions by calling plgxax.\n"
21003  "\n"
21004  ""},
21005  { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21006  "Set y axis parameters\n"
21007  "\n"
21008  "DESCRIPTION:\n"
21009  "\n"
21010  " Identical to plsxax, except that arguments are flags for y axis. See\n"
21011  " the description of plsxax for more detail.\n"
21012  "\n"
21013  " Redacted form: plsyax(digmax, digits)\n"
21014  "\n"
21015  " This function is used in examples 1, 14, and 31.\n"
21016  "\n"
21017  "\n"
21018  "\n"
21019  "SYNOPSIS:\n"
21020  "\n"
21021  "plsyax(digmax, digits)\n"
21022  "\n"
21023  "ARGUMENTS:\n"
21024  "\n"
21025  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21026  " digits for the y axis. If nonzero, the printed label will be\n"
21027  " switched to a floating-point representation when the number of\n"
21028  " digits exceeds digmax.\n"
21029  "\n"
21030  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21031  " its value here has no effect since it is set only by plbox or\n"
21032  " plbox3. However, the user may obtain its value after a call to\n"
21033  " either of these functions by calling plgyax.\n"
21034  "\n"
21035  ""},
21036  { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21037  "Plot a glyph at the specified points\n"
21038  "\n"
21039  "DESCRIPTION:\n"
21040  "\n"
21041  " Plot a glyph at the specified points. (This function is largely\n"
21042  " superseded by plstring which gives access to many[!] more glyphs.)\n"
21043  "\n"
21044  " Redacted form: plsym(x, y, code)\n"
21045  "\n"
21046  " This function is used in example 7.\n"
21047  "\n"
21048  "\n"
21049  "\n"
21050  "SYNOPSIS:\n"
21051  "\n"
21052  "plsym(n, x, y, code)\n"
21053  "\n"
21054  "ARGUMENTS:\n"
21055  "\n"
21056  " n (PLINT, input) : Number of points in the x and y vectors.\n"
21057  "\n"
21058  " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21059  " the points.\n"
21060  "\n"
21061  " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21062  " the points.\n"
21063  "\n"
21064  " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21065  " to be plotted at each of the n points.\n"
21066  "\n"
21067  ""},
21068  { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21069  "Set z axis parameters\n"
21070  "\n"
21071  "DESCRIPTION:\n"
21072  "\n"
21073  " Identical to plsxax, except that arguments are flags for z axis. See\n"
21074  " the description of plsxax for more detail.\n"
21075  "\n"
21076  " Redacted form: plszax(digmax, digits)\n"
21077  "\n"
21078  " This function is used in example 31.\n"
21079  "\n"
21080  "\n"
21081  "\n"
21082  "SYNOPSIS:\n"
21083  "\n"
21084  "plszax(digmax, digits)\n"
21085  "\n"
21086  "ARGUMENTS:\n"
21087  "\n"
21088  " digmax (PLINT, input) : Variable to set the maximum number of\n"
21089  " digits for the z axis. If nonzero, the printed label will be\n"
21090  " switched to a floating-point representation when the number of\n"
21091  " digits exceeds digmax.\n"
21092  "\n"
21093  " digits (PLINT, input) : Field digits value. Currently, changing\n"
21094  " its value here has no effect since it is set only by plbox or\n"
21095  " plbox3. However, the user may obtain its value after a call to\n"
21096  " either of these functions by calling plgzax.\n"
21097  "\n"
21098  ""},
21099  { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21100  "Switch to text screen\n"
21101  "\n"
21102  "DESCRIPTION:\n"
21103  "\n"
21104  " Sets an interactive device to text mode, used in conjunction with\n"
21105  " plgra to allow graphics and text to be interspersed. On a device\n"
21106  " which supports separate text and graphics windows, this command causes\n"
21107  " control to be switched to the text window. This can be useful for\n"
21108  " printing diagnostic messages or getting user input, which would\n"
21109  " otherwise interfere with the plots. The program must switch back to\n"
21110  " the graphics window before issuing plot commands, as the text (or\n"
21111  " console) device will probably become quite confused otherwise. If\n"
21112  " already in text mode, this command is ignored. It is also ignored on\n"
21113  " devices which only support a single window or use a different method\n"
21114  " for shifting focus (see also plgra).\n"
21115  "\n"
21116  " Redacted form: pltext()\n"
21117  "\n"
21118  " This function is used in example 1.\n"
21119  "\n"
21120  "\n"
21121  "\n"
21122  "SYNOPSIS:\n"
21123  "\n"
21124  "pltext()\n"
21125  "\n"
21126  ""},
21127  { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21128  "Set format for date / time labels\n"
21129  "\n"
21130  "DESCRIPTION:\n"
21131  "\n"
21132  " Sets the format for date / time labels. To enable date / time format\n"
21133  " labels see the options to plbox, plbox3, and plenv.\n"
21134  "\n"
21135  " Redacted form: pltimefmt(fmt)\n"
21136  "\n"
21137  " This function is used in example 29.\n"
21138  "\n"
21139  "\n"
21140  "\n"
21141  "SYNOPSIS:\n"
21142  "\n"
21143  "pltimefmt(fmt)\n"
21144  "\n"
21145  "ARGUMENTS:\n"
21146  "\n"
21147  " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21148  " interpreted similarly to the format specifier of typical system\n"
21149  " strftime routines except that PLplot ignores locale and also\n"
21150  " supplies some useful extensions in the context of plotting. All\n"
21151  " text in the string is printed as-is other than conversion\n"
21152  " specifications which take the form of a '%' character followed by\n"
21153  " further conversion specification character. The conversion\n"
21154  " specifications which are similar to those provided by system\n"
21155  " strftime routines are the following: %a: The abbreviated (English)\n"
21156  " weekday name.\n"
21157  " %A: The full (English) weekday name.\n"
21158  " %b: The abbreviated (English) month name.\n"
21159  " %B: The full (English) month name.\n"
21160  " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21161  " %C: The century number (year/100) as a 2-digit integer.\n"
21162  " %d: The day of the month as a decimal number (range 01 to 31).\n"
21163  " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21164  " %e: Like %d, but a leading zero is replaced by a space.\n"
21165  " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21166  " %h: Equivalent to %b.\n"
21167  " %H: The hour as a decimal number using a 24-hour clock (range\n"
21168  " 00 to 23).\n"
21169  " %I: The hour as a decimal number using a 12-hour clock (range\n"
21170  " 01 to 12).\n"
21171  " %j: The day of the year as a decimal number (range 001 to\n"
21172  " 366).\n"
21173  " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21174  " 23); single digits are preceded by a blank. (See also %H.)\n"
21175  " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21176  " 12); single digits are preceded by a blank. (See also %I.)\n"
21177  " %m: The month as a decimal number (range 01 to 12).\n"
21178  " %M: The minute as a decimal number (range 00 to 59).\n"
21179  " %n: A newline character.\n"
21180  " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21181  " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21182  " %r: Equivalent to %I:%M:%S %p.\n"
21183  " %R: The time in 24-hour notation (%H:%M). For a version\n"
21184  " including the seconds, see %T below.\n"
21185  " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21186  " +0000 (UTC).\n"
21187  " %S: The second as a decimal number (range 00 to 60). (The\n"
21188  " range is up to 60 to allow for occasional leap seconds.)\n"
21189  " %t: A tab character.\n"
21190  " %T: The time in 24-hour notation (%H:%M:%S).\n"
21191  " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21192  " being 1. See also %w.\n"
21193  " %U: The week number of the current year as a decimal number,\n"
21194  " range 00 to 53, starting with the first Sunday as the first\n"
21195  " day of week 01. See also %V and %W.\n"
21196  " %v: Equivalent to %e-%b-%Y.\n"
21197  " %V: The ISO 8601 week number of the current year as a decimal\n"
21198  " number, range 01 to 53, where week 1 is the first week that\n"
21199  " has at least 4 days in the new year. See also %U and %W.\n"
21200  " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21201  " being 0. See also %u.\n"
21202  " %W: The week number of the current year as a decimal number,\n"
21203  " range 00 to 53, starting with the first Monday as the first\n"
21204  " day of week 01.\n"
21205  " %x: Equivalent to %a %b %d %Y.\n"
21206  " %X: Equivalent to %T.\n"
21207  " %y: The year as a decimal number without a century (range 00\n"
21208  " to 99).\n"
21209  " %Y: The year as a decimal number including a century.\n"
21210  " %z: The UTC time-zone string = \"+0000\".\n"
21211  " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21212  " %+: The UTC date and time in default format of the Unix date\n"
21213  " command which is equivalent to %a %b %d %T %Z %Y.\n"
21214  " %%: A literal \"%\" character.\n"
21215  " The conversion specifications which are extensions to those normally\n"
21216  " provided by system strftime routines are the following: %(0-9):\n"
21217  " The fractional part of the seconds field (including leading\n"
21218  " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21219  " seconds to millisecond accuracy (00.000).\n"
21220  " %.: The fractional part of the seconds field (including\n"
21221  " leading decimal point) to the maximum available accuracy. Thus\n"
21222  " %S%. would give seconds with fractional part up to 9 decimal\n"
21223  " places if available.\n"
21224  "\n"
21225  ""},
21226  { "plvasp", _wrap_plvasp, METH_O, "\n"
21227  "Specify viewport using aspect ratio only\n"
21228  "\n"
21229  "DESCRIPTION:\n"
21230  "\n"
21231  " Selects the largest viewport with the given aspect ratio within the\n"
21232  " subpage that leaves a standard margin (left-hand margin of eight\n"
21233  " character heights, and a margin around the other three sides of five\n"
21234  " character heights).\n"
21235  "\n"
21236  " Redacted form: plvasp(aspect)\n"
21237  "\n"
21238  " This function is used in example 13.\n"
21239  "\n"
21240  "\n"
21241  "\n"
21242  "SYNOPSIS:\n"
21243  "\n"
21244  "plvasp(aspect)\n"
21245  "\n"
21246  "ARGUMENTS:\n"
21247  "\n"
21248  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21249  " axis of resulting viewport.\n"
21250  "\n"
21251  ""},
21252  { "plvect", _wrap_plvect, METH_VARARGS, "\n"
21253  "Vector plot\n"
21254  "\n"
21255  "DESCRIPTION:\n"
21256  "\n"
21257  " Draws a plot of vector data contained in the matrices (\n"
21258  " u[\n"
21259  " nx][\n"
21260  " ny],\n"
21261  " v[\n"
21262  " nx][\n"
21263  " ny]) . The scaling factor for the vectors is given by scale. A\n"
21264  " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21265  " additional data required by the transformation routine to map indices\n"
21266  " within the matrices to the world coordinates. The style of the vector\n"
21267  " arrow may be set using plsvect.\n"
21268  "\n"
21269  " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21270  " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21271  " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21272  " with either one or two dimensions.\n"
21273  "\n"
21274  " This function is used in example 22.\n"
21275  "\n"
21276  "\n"
21277  "\n"
21278  "SYNOPSIS:\n"
21279  "\n"
21280  "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21281  "\n"
21282  "ARGUMENTS:\n"
21283  "\n"
21284  " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21285  " and y components of the vector data to be plotted.\n"
21286  "\n"
21287  " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21288  "\n"
21289  " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21290  " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21291  " automatically calculated for the data. If scale < 0 then the\n"
21292  " scaling factor is automatically calculated for the data and then\n"
21293  " multiplied by -\n"
21294  " scale. If scale > 0 then the scaling factor is set to scale.\n"
21295  "\n"
21296  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21297  " defines the transformation between the zero-based indices of the\n"
21298  " matrices u and v and world coordinates.For the C case,\n"
21299  " transformation functions are provided in the PLplot library: pltr0\n"
21300  " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21301  " mappings respectively defined by vectors and matrices. In\n"
21302  " addition, C callback routines for the transformation can be\n"
21303  " supplied by the user such as the mypltr function in\n"
21304  " examples/c/x09c.c which provides a general linear transformation\n"
21305  " between index coordinates and world coordinates.For languages\n"
21306  " other than C you should consult the PLplot documentation for the\n"
21307  " details concerning how PLTRANSFORM_callback arguments are\n"
21308  " interfaced. However, in general, a particular pattern of\n"
21309  " callback-associated arguments such as a tr vector with 6 elements;\n"
21310  " xg and yg vectors; or xg and yg matrices are respectively\n"
21311  " interfaced to a linear-transformation routine similar to the above\n"
21312  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21313  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21314  " support native language callbacks for handling index to\n"
21315  " world-coordinate transformations. Examples of these various\n"
21316  " approaches are given in examples/<language>x09*,\n"
21317  " examples/<language>x16*, examples/<language>x20*,\n"
21318  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21319  " supported languages.\n"
21320  "\n"
21321  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21322  " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
21323  " that is externally supplied.\n"
21324  "\n"
21325  ""},
21326  { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
21327  "Specify viewport using coordinates and aspect ratio\n"
21328  "\n"
21329  "DESCRIPTION:\n"
21330  "\n"
21331  " Device-independent routine for setting up the viewport. The viewport\n"
21332  " is chosen to be the largest with the given aspect ratio that fits\n"
21333  " within the specified region (in terms of normalized subpage\n"
21334  " coordinates). This routine is functionally equivalent to plvpor when\n"
21335  " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21336  " routine reserves no extra space at the edges for labels.\n"
21337  "\n"
21338  " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21339  "\n"
21340  " This function is used in example 9.\n"
21341  "\n"
21342  "\n"
21343  "\n"
21344  "SYNOPSIS:\n"
21345  "\n"
21346  "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21347  "\n"
21348  "ARGUMENTS:\n"
21349  "\n"
21350  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21351  " left-hand edge of the viewport.\n"
21352  "\n"
21353  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21354  " right-hand edge of the viewport.\n"
21355  "\n"
21356  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21357  " bottom edge of the viewport.\n"
21358  "\n"
21359  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21360  " edge of the viewport.\n"
21361  "\n"
21362  " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21363  " axis.\n"
21364  "\n"
21365  ""},
21366  { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
21367  "Specify viewport using normalized subpage coordinates\n"
21368  "\n"
21369  "DESCRIPTION:\n"
21370  "\n"
21371  " Device-independent routine for setting up the viewport. This defines\n"
21372  " the viewport in terms of normalized subpage coordinates which run from\n"
21373  " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21374  " current subpage. Use the alternate routine plsvpa in order to create\n"
21375  " a viewport of a definite size.\n"
21376  "\n"
21377  " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21378  "\n"
21379  " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
21380  " 24, 26, 27, and 31.\n"
21381  "\n"
21382  "\n"
21383  "\n"
21384  "SYNOPSIS:\n"
21385  "\n"
21386  "plvpor(xmin, xmax, ymin, ymax)\n"
21387  "\n"
21388  "ARGUMENTS:\n"
21389  "\n"
21390  " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21391  " left-hand edge of the viewport.\n"
21392  "\n"
21393  " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21394  " right-hand edge of the viewport.\n"
21395  "\n"
21396  " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21397  " bottom edge of the viewport.\n"
21398  "\n"
21399  " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21400  " edge of the viewport.\n"
21401  "\n"
21402  ""},
21403  { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
21404  "Select standard viewport\n"
21405  "\n"
21406  "DESCRIPTION:\n"
21407  "\n"
21408  " Selects the largest viewport within the subpage that leaves a standard\n"
21409  " margin (left-hand margin of eight character heights, and a margin\n"
21410  " around the other three sides of five character heights).\n"
21411  "\n"
21412  " Redacted form: plvsta()\n"
21413  "\n"
21414  " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
21415  "\n"
21416  "\n"
21417  "\n"
21418  "SYNOPSIS:\n"
21419  "\n"
21420  "plvsta()\n"
21421  "\n"
21422  ""},
21423  { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
21424  "Configure the transformations required for projecting a 3D surface on a 2D window\n"
21425  "\n"
21426  "DESCRIPTION:\n"
21427  "\n"
21428  " Configure the transformations required for projecting a 3D surface on\n"
21429  " an existing 2D window. Those transformations (see the PLplot\n"
21430  " documentation) are done to a rectangular cuboid enclosing the 3D\n"
21431  " surface which has its limits expressed in 3D world coordinates and\n"
21432  " also normalized 3D coordinates (used for interpreting the altitude and\n"
21433  " azimuth of the viewing angle). The transformations consist of the\n"
21434  " linear transform from 3D world coordinates to normalized 3D\n"
21435  " coordinates, and the 3D rotation of normalized coordinates required to\n"
21436  " align the pole of the new 3D coordinate system with the viewing\n"
21437  " direction specified by altitude and azimuth so that x and y of the\n"
21438  " surface elements in that transformed coordinate system are the\n"
21439  " projection of the 3D surface with given viewing direction on the 2D\n"
21440  " window.\n"
21441  "\n"
21442  " The enclosing rectangular cuboid for the surface plot is defined by\n"
21443  " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
21444  " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
21445  " sizes of basex by basey by height so that xmin maps to -\n"
21446  " basex/2, xmax maps to basex/2, ymin maps to -\n"
21447  " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21448  " The resulting rectangular cuboid in normalized coordinates is then\n"
21449  " viewed by an observer at altitude alt and azimuth az. This routine\n"
21450  " must be called before plbox3 or any of the 3D surface plotting\n"
21451  " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
21452  " plsurf3dl or plfill3.\n"
21453  "\n"
21454  " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21455  " zmin, zmax, alt, az)\n"
21456  "\n"
21457  " This function is examples 8, 11, 18, and 21.\n"
21458  "\n"
21459  "\n"
21460  "\n"
21461  "SYNOPSIS:\n"
21462  "\n"
21463  "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21464  "\n"
21465  "ARGUMENTS:\n"
21466  "\n"
21467  " basex (PLFLT, input) : The normalized x coordinate size of the\n"
21468  " rectangular cuboid.\n"
21469  "\n"
21470  " basey (PLFLT, input) : The normalized y coordinate size of the\n"
21471  " rectangular cuboid.\n"
21472  "\n"
21473  " height (PLFLT, input) : The normalized z coordinate size of the\n"
21474  " rectangular cuboid.\n"
21475  "\n"
21476  " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
21477  " rectangular cuboid.\n"
21478  "\n"
21479  " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
21480  " rectangular cuboid.\n"
21481  "\n"
21482  " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
21483  " rectangular cuboid.\n"
21484  "\n"
21485  " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
21486  " rectangular cuboid.\n"
21487  "\n"
21488  " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
21489  " rectangular cuboid.\n"
21490  "\n"
21491  " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
21492  " rectangular cuboid.\n"
21493  "\n"
21494  " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
21495  " plane of the rectangular cuboid in normalized coordinates.\n"
21496  "\n"
21497  " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
21498  " rectangular cuboid in normalized coordinates. When az=0, the\n"
21499  " observer is looking face onto the zx plane of the rectangular\n"
21500  " cuboid in normalized coordinates, and as az is increased, the\n"
21501  " observer moves clockwise around that cuboid when viewed from above\n"
21502  " the xy plane.\n"
21503  "\n"
21504  ""},
21505  { "plwidth", _wrap_plwidth, METH_O, "\n"
21506  "Set pen width\n"
21507  "\n"
21508  "DESCRIPTION:\n"
21509  "\n"
21510  " Sets the pen width.\n"
21511  "\n"
21512  " Redacted form: plwidth(width)\n"
21513  "\n"
21514  " This function is used in examples 1 and 2.\n"
21515  "\n"
21516  "\n"
21517  "\n"
21518  "SYNOPSIS:\n"
21519  "\n"
21520  "plwidth(width)\n"
21521  "\n"
21522  "ARGUMENTS:\n"
21523  "\n"
21524  " width (PLFLT, input) : The desired pen width. If width is negative\n"
21525  " or the same as the previous value no action is taken. width = 0.\n"
21526  " should be interpreted as as the minimum valid pen width for the\n"
21527  " device. The interpretation of positive width values is also\n"
21528  " device dependent.\n"
21529  "\n"
21530  ""},
21531  { "plwind", _wrap_plwind, METH_VARARGS, "\n"
21532  "Specify window\n"
21533  "\n"
21534  "DESCRIPTION:\n"
21535  "\n"
21536  " Specify the window, i.e., the world coordinates of the edges of the\n"
21537  " viewport.\n"
21538  "\n"
21539  " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21540  "\n"
21541  " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
21542  " 29, and 31.\n"
21543  "\n"
21544  "\n"
21545  "\n"
21546  "SYNOPSIS:\n"
21547  "\n"
21548  "plwind(xmin, xmax, ymin, ymax)\n"
21549  "\n"
21550  "ARGUMENTS:\n"
21551  "\n"
21552  " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21553  " of the viewport.\n"
21554  "\n"
21555  " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21556  " of the viewport.\n"
21557  "\n"
21558  " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21559  " the viewport.\n"
21560  "\n"
21561  " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21562  " viewport.\n"
21563  "\n"
21564  ""},
21565  { "plxormod", _wrap_plxormod, METH_O, "\n"
21566  "Enter or leave xor mode\n"
21567  "\n"
21568  "DESCRIPTION:\n"
21569  "\n"
21570  " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21571  " those drivers (e.g., the xwin driver) that support it. Enables\n"
21572  " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21573  " is not capable of xor operation it returns a status of false.\n"
21574  "\n"
21575  " Redacted form: plxormod(mode, status)\n"
21576  "\n"
21577  " This function is used in examples 1 and 20.\n"
21578  "\n"
21579  "\n"
21580  "\n"
21581  "SYNOPSIS:\n"
21582  "\n"
21583  "plxormod(mode, status)\n"
21584  "\n"
21585  "ARGUMENTS:\n"
21586  "\n"
21587  " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21588  " is false means leave xor mode.\n"
21589  "\n"
21590  " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
21591  " modestatus of true (false) means driver is capable (incapable) of\n"
21592  " xor mode.\n"
21593  "\n"
21594  ""},
21595  { "plmap", _wrap_plmap, METH_VARARGS, "\n"
21596  "Plot continental outline or shapefile data in world coordinates\n"
21597  "\n"
21598  "DESCRIPTION:\n"
21599  "\n"
21600  " Plots continental outlines or shapefile data in world coordinates. A\n"
21601  " demonstration of how to use this function to create different\n"
21602  " projections can be found in examples/c/x19c. PLplot is provided with\n"
21603  " basic coastal outlines and USA state borders. To use the map\n"
21604  " functionality PLplot must be compiled with the shapelib library.\n"
21605  " Shapefiles have become a popular standard for geographical data and\n"
21606  " data in this format can be easily found from a number of online\n"
21607  " sources. Shapefile data is actually provided as three or more files\n"
21608  " with the same filename, but different extensions. The .shp and .shx\n"
21609  " files are required for plotting Shapefile data with PLplot.\n"
21610  "\n"
21611  " PLplot currently supports the point, multipoint, polyline and polygon\n"
21612  " objects within shapefiles. However holes in polygons are not\n"
21613  " supported. When plmap is used the type of object is derived from the\n"
21614  " shapefile, if you wish to override the type then use one of the other\n"
21615  " plmap variants. The built in maps have line data only.\n"
21616  "\n"
21617  " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21618  "\n"
21619  " This function is used in example 19.\n"
21620  "\n"
21621  "\n"
21622  "\n"
21623  "SYNOPSIS:\n"
21624  "\n"
21625  "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21626  "\n"
21627  "ARGUMENTS:\n"
21628  "\n"
21629  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21630  " transform the original map data coordinates to a new coordinate\n"
21631  " system. The PLplot-supplied map data is provided as latitudes and\n"
21632  " longitudes; other Shapefile data may be provided in other\n"
21633  " coordinate systems as can be found in their .prj plain text files.\n"
21634  " For example, by using this transform we can change from a\n"
21635  " longitude, latitude coordinate to a polar stereographic\n"
21636  " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
21637  " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
21638  " corresponding y coordinates (latitudes for the PLplot supplied\n"
21639  " data). After the call to mapform(), x[] and y[] should be\n"
21640  " replaced by the corresponding plot coordinates. If no transform is\n"
21641  " desired, mapform can be replaced by NULL.\n"
21642  "\n"
21643  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21644  " the type of map plotted. This is either one of the PLplot built-in\n"
21645  " maps or the file name of a set of Shapefile files without the file\n"
21646  " extensions. For the PLplot built-in maps the possible values are:\n"
21647  " \"globe\" -- continental outlines\n"
21648  " \"usa\" -- USA and state boundaries\n"
21649  " \"cglobe\" -- continental outlines and countries\n"
21650  " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
21651  "\n"
21652  "\n"
21653  " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21654  " drawn. The units must match the shapefile (built in maps are\n"
21655  " degrees lat/lon). Objects in the file which do not encroach on the\n"
21656  " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
21657  " note this is simply an optimisation, not a clipping so for objects\n"
21658  " with some points inside the box and some points outside the box\n"
21659  " all the points will be rendered. These parameters also define\n"
21660  " latitude and longitude wrapping for shapefiles using these units.\n"
21661  " Longitude points will be wrapped by integer multiples of 360\n"
21662  " degrees to place them in the box. This allows the same data to be\n"
21663  " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
21664  " you plot from -180-540 you will get two cycles of data drawn. The\n"
21665  " value of minx must be less than the value of maxx. Passing in a\n"
21666  " nan, max/-max floating point number or +/-infinity will case the\n"
21667  " bounding box from the shapefile to be used.\n"
21668  "\n"
21669  " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21670  " drawn - see minx.\n"
21671  "\n"
21672  " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21673  " drawn - see minx.\n"
21674  "\n"
21675  " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21676  " drawn - see minx.\n"
21677  "\n"
21678  ""},
21679  { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
21680  "Plot all or a subset of Shapefile data using lines in world coordinates\n"
21681  "\n"
21682  "DESCRIPTION:\n"
21683  "\n"
21684  " Plot all or a subset of Shapefile data using lines in world\n"
21685  " coordinates. Our 19th standard example demonstrates how to use this\n"
21686  " function. This function plots data from a Shapefile using lines as in\n"
21687  " plmap, however it also has the option of also only drawing specified\n"
21688  " elements from the Shapefile. The vector of indices of the required\n"
21689  " elements are passed as a function argument. The Shapefile data should\n"
21690  " include a metadata file (extension.dbf) listing all items within the\n"
21691  " Shapefile. This file can be opened by most popular spreadsheet\n"
21692  " programs and can be used to decide which indices to pass to this\n"
21693  " function.\n"
21694  "\n"
21695  " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21696  " plotentries)\n"
21697  "\n"
21698  " This function is used in example 19.\n"
21699  "\n"
21700  "\n"
21701  "\n"
21702  "SYNOPSIS:\n"
21703  "\n"
21704  "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21705  "\n"
21706  "ARGUMENTS:\n"
21707  "\n"
21708  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21709  " transform the coordinates given in the shapefile into a plot\n"
21710  " coordinate system. By using this transform, we can change from a\n"
21711  " longitude, latitude coordinate to a polar stereographic project,\n"
21712  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21713  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21714  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21715  " plot coordinates. If no transform is desired, mapform can be\n"
21716  " replaced by NULL.\n"
21717  "\n"
21718  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21719  " the file name of a set of Shapefile files without the file\n"
21720  " extension.\n"
21721  "\n"
21722  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21723  " be in the same units as used by the Shapefile. You could use a\n"
21724  " very large negative number to plot everything, but you can improve\n"
21725  " performance by limiting the area drawn. The units must match those\n"
21726  " of the Shapefile projection, which may be for example longitude or\n"
21727  " distance. The value of minx must be less than the value of maxx.\n"
21728  "\n"
21729  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21730  " use a very large number to plot everything, but you can improve\n"
21731  " performance by limiting the area drawn.\n"
21732  "\n"
21733  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21734  " be in the same units as used by the Shapefile. You could use a\n"
21735  " very large negative number to plot everything, but you can improve\n"
21736  " performance by limiting the area drawn. The units must match those\n"
21737  " of the Shapefile projection, which may be for example latitude or\n"
21738  " distance. The value of miny must be less than the value of maxy.\n"
21739  "\n"
21740  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21741  " use a very large number to plot everything, but you can improve\n"
21742  " performance by limiting the area drawn.\n"
21743  "\n"
21744  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21745  " zero-based indices of the Shapefile elements which will be drawn.\n"
21746  " Setting\n"
21747  " plotentries to NULL will plot all elements of the Shapefile.\n"
21748  "\n"
21749  " nplotentries (PLINT, input) : The number of items in\n"
21750  " plotentries. Ignored if\n"
21751  " plotentries is NULL.\n"
21752  "\n"
21753  ""},
21754  { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
21755  "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
21756  "\n"
21757  "DESCRIPTION:\n"
21758  "\n"
21759  " As per plmapline, however the items are plotted as strings or points\n"
21760  " in the same way as plstring.\n"
21761  "\n"
21762  " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
21763  " maxy, plotentries)\n"
21764  "\n"
21765  " This function is not used in any examples.\n"
21766  "\n"
21767  "\n"
21768  "\n"
21769  "SYNOPSIS:\n"
21770  "\n"
21771  "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21772  "\n"
21773  "ARGUMENTS:\n"
21774  "\n"
21775  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21776  " transform the coordinates given in the shapefile into a plot\n"
21777  " coordinate system. By using this transform, we can change from a\n"
21778  " longitude, latitude coordinate to a polar stereographic project,\n"
21779  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21780  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21781  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21782  " plot coordinates. If no transform is desired, mapform can be\n"
21783  " replaced by NULL.\n"
21784  "\n"
21785  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21786  " the file name of a set of Shapefile files without the file\n"
21787  " extension.\n"
21788  "\n"
21789  " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
21790  " drawn.\n"
21791  "\n"
21792  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21793  " be in the same units as used by the Shapefile. You could use a\n"
21794  " very large negative number to plot everything, but you can improve\n"
21795  " performance by limiting the area drawn. The units must match those\n"
21796  " of the Shapefile projection, which may be for example longitude or\n"
21797  " distance. The value of minx must be less than the value of maxx.\n"
21798  "\n"
21799  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21800  " use a very large number to plot everything, but you can improve\n"
21801  " performance by limiting the area drawn.\n"
21802  "\n"
21803  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21804  " be in the same units as used by the Shapefile. You could use a\n"
21805  " very large negative number to plot everything, but you can improve\n"
21806  " performance by limiting the area drawn. The units must match those\n"
21807  " of the Shapefile projection, which may be for example latitude or\n"
21808  " distance. The value of miny must be less than the value of maxy.\n"
21809  "\n"
21810  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21811  " use a very large number to plot everything, but you can improve\n"
21812  " performance by limiting the area drawn.\n"
21813  "\n"
21814  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21815  " zero-based indices of the Shapefile elements which will be drawn.\n"
21816  " Setting\n"
21817  " plotentries to NULL will plot all elements of the Shapefile.\n"
21818  "\n"
21819  " nplotentries (PLINT, input) : The number of items in\n"
21820  " plotentries. Ignored if\n"
21821  " plotentries is NULL.\n"
21822  "\n"
21823  ""},
21824  { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
21825  "Draw text at points defined by Shapefile data in world coordinates\n"
21826  "\n"
21827  "DESCRIPTION:\n"
21828  "\n"
21829  " As per plmapline, however the items are plotted as text in the same\n"
21830  " way as plptex.\n"
21831  "\n"
21832  " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
21833  " miny, maxy, plotentry)\n"
21834  "\n"
21835  " This function is used in example 19.\n"
21836  "\n"
21837  "\n"
21838  "\n"
21839  "SYNOPSIS:\n"
21840  "\n"
21841  "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
21842  "\n"
21843  "ARGUMENTS:\n"
21844  "\n"
21845  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21846  " transform the coordinates given in the shapefile into a plot\n"
21847  " coordinate system. By using this transform, we can change from a\n"
21848  " longitude, latitude coordinate to a polar stereographic project,\n"
21849  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21850  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21851  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21852  " plot coordinates. If no transform is desired, mapform can be\n"
21853  " replaced by NULL.\n"
21854  "\n"
21855  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21856  " the file name of a set of Shapefile files without the file\n"
21857  " extension.\n"
21858  "\n"
21859  " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
21860  " dy/dx.\n"
21861  "\n"
21862  " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
21863  " dy/dx.\n"
21864  "\n"
21865  " just (PLFLT, input) : Set the justification of the text. The value\n"
21866  " given will be the fraction of the distance along the string that\n"
21867  " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
21868  " centralized text and 1.0 gives right aligned text.\n"
21869  "\n"
21870  " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
21871  "\n"
21872  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21873  " be in the same units as used by the Shapefile. You could use a\n"
21874  " very large negative number to plot everything, but you can improve\n"
21875  " performance by limiting the area drawn. The units must match those\n"
21876  " of the Shapefile projection, which may be for example longitude or\n"
21877  " distance. The value of minx must be less than the value of maxx.\n"
21878  "\n"
21879  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21880  " use a very large number to plot everything, but you can improve\n"
21881  " performance by limiting the area drawn.\n"
21882  "\n"
21883  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21884  " be in the same units as used by the Shapefile. You could use a\n"
21885  " very large negative number to plot everything, but you can improve\n"
21886  " performance by limiting the area drawn. The units must match those\n"
21887  " of the Shapefile projection, which may be for example latitude or\n"
21888  " distance. The value of miny must be less than the value of maxy.\n"
21889  "\n"
21890  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21891  " use a very large number to plot everything, but you can improve\n"
21892  " performance by limiting the area drawn.\n"
21893  "\n"
21894  " plotentry (PLINT, input) : An integer indicating which text string\n"
21895  " of the Shapefile (zero indexed) will be drawn.\n"
21896  "\n"
21897  ""},
21898  { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
21899  "Plot all or a subset of Shapefile data, filling the polygons\n"
21900  "\n"
21901  "DESCRIPTION:\n"
21902  "\n"
21903  " As per plmapline, however the items are filled in the same way as\n"
21904  " plfill.\n"
21905  "\n"
21906  " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
21907  " plotentries)\n"
21908  "\n"
21909  " This function is used in example 19.\n"
21910  "\n"
21911  "\n"
21912  "\n"
21913  "SYNOPSIS:\n"
21914  "\n"
21915  "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21916  "\n"
21917  "ARGUMENTS:\n"
21918  "\n"
21919  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21920  " transform the coordinates given in the shapefile into a plot\n"
21921  " coordinate system. By using this transform, we can change from a\n"
21922  " longitude, latitude coordinate to a polar stereographic project,\n"
21923  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21924  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21925  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21926  " plot coordinates. If no transform is desired, mapform can be\n"
21927  " replaced by NULL.\n"
21928  "\n"
21929  " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21930  " the file name of a set of Shapefile files without the file\n"
21931  " extension.\n"
21932  "\n"
21933  " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21934  " be in the same units as used by the Shapefile. You could use a\n"
21935  " very large negative number to plot everything, but you can improve\n"
21936  " performance by limiting the area drawn. The units must match those\n"
21937  " of the Shapefile projection, which may be for example longitude or\n"
21938  " distance. The value of minx must be less than the value of maxx.\n"
21939  "\n"
21940  " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21941  " use a very large number to plot everything, but you can improve\n"
21942  " performance by limiting the area drawn.\n"
21943  "\n"
21944  " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21945  " be in the same units as used by the Shapefile. You could use a\n"
21946  " very large negative number to plot everything, but you can improve\n"
21947  " performance by limiting the area drawn. The units must match those\n"
21948  " of the Shapefile projection, which may be for example latitude or\n"
21949  " distance. The value of miny must be less than the value of maxy.\n"
21950  "\n"
21951  " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21952  " use a very large number to plot everything, but you can improve\n"
21953  " performance by limiting the area drawn.\n"
21954  "\n"
21955  " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21956  " zero-based indices of the Shapefile elements which will be drawn.\n"
21957  " Setting\n"
21958  " plotentries to NULL will plot all elements of the Shapefile.\n"
21959  "\n"
21960  " nplotentries (PLINT, input) : The number of items in\n"
21961  " plotentries. Ignored if\n"
21962  " plotentries is NULL.\n"
21963  "\n"
21964  ""},
21965  { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
21966  "Plot latitude and longitude lines\n"
21967  "\n"
21968  "DESCRIPTION:\n"
21969  "\n"
21970  " Displays latitude and longitude on the current plot. The lines are\n"
21971  " plotted in the current color and line style.\n"
21972  "\n"
21973  " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
21974  " minlat, maxlat)\n"
21975  "\n"
21976  " This function is used in example 19.\n"
21977  "\n"
21978  "\n"
21979  "\n"
21980  "SYNOPSIS:\n"
21981  "\n"
21982  "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
21983  "\n"
21984  "ARGUMENTS:\n"
21985  "\n"
21986  " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21987  " transform the coordinate longitudes and latitudes to a plot\n"
21988  " coordinate system. By using this transform, we can change from a\n"
21989  " longitude, latitude coordinate to a polar stereographic project,\n"
21990  " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21991  " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21992  " mapform(), x[] and y[] should be replaced by the corresponding\n"
21993  " plot coordinates. If no transform is desired, mapform can be\n"
21994  " replaced by NULL.\n"
21995  "\n"
21996  " dlong (PLFLT, input) : The interval in degrees at which the\n"
21997  " longitude lines are to be plotted.\n"
21998  "\n"
21999  " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22000  " lines are to be plotted.\n"
22001  "\n"
22002  " minlong (PLFLT, input) : The value of the longitude on the left\n"
22003  " side of the plot. The value of minlong must be less than the value\n"
22004  " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22005  " equal to 360.\n"
22006  "\n"
22007  " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22008  " side of the plot.\n"
22009  "\n"
22010  " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22011  " background. One can always use -90.0 as the boundary outside the\n"
22012  " plot window will be automatically eliminated. However, the\n"
22013  " program will be faster if one can reduce the size of the\n"
22014  " background plotted.\n"
22015  "\n"
22016  " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22017  " background. One can always use 90.0 as the boundary outside the\n"
22018  " plot window will be automatically eliminated.\n"
22019  "\n"
22020  ""},
22021  { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22022  "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22023  "\n"
22024  "DESCRIPTION:\n"
22025  "\n"
22026  " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22027  " automatically adjusted to use the maximum and minimum values in idata\n"
22028  " as valuemin and valuemax in a call to plimagefr.\n"
22029  "\n"
22030  " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22031  " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22032  "\n"
22033  "\n"
22034  " This function is used in example 20.\n"
22035  "\n"
22036  "\n"
22037  "\n"
22038  "SYNOPSIS:\n"
22039  "\n"
22040  "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22041  "\n"
22042  "ARGUMENTS:\n"
22043  "\n"
22044  " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22045  " to plot. Should have dimensions of\n"
22046  " nx by\n"
22047  " ny.\n"
22048  "\n"
22049  " nx, ny (PLINT, input) : Dimensions of idata\n"
22050  "\n"
22051  " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22052  " are linearly transformed to these world coordinate ranges such\n"
22053  " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22054  " - 1] corresponds to (xmax, ymax).\n"
22055  "\n"
22056  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22057  " (inclusive) will be plotted.\n"
22058  "\n"
22059  " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22060  " points whose plot coordinates fall inside the window of (Dxmin,\n"
22061  " Dymin) to (Dxmax, Dymax).\n"
22062  "\n"
22063  ""},
22064  { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22065  "Plot a 2D matrix using cmap1\n"
22066  "\n"
22067  "DESCRIPTION:\n"
22068  "\n"
22069  " Plot a 2D matrix using cmap1.\n"
22070  "\n"
22071  " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22072  " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22073  "\n"
22074  "\n"
22075  " This function is used in example 20.\n"
22076  "\n"
22077  "\n"
22078  "\n"
22079  "SYNOPSIS:\n"
22080  "\n"
22081  "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22082  "\n"
22083  "ARGUMENTS:\n"
22084  "\n"
22085  " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22086  " plot. Should have dimensions of\n"
22087  " nx by\n"
22088  " ny.\n"
22089  "\n"
22090  " nx, ny (PLINT, input) : Dimensions of idata\n"
22091  "\n"
22092  " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22093  " pltr below for how these arguments are used (only for the special case\n"
22094  " when the callback function\n"
22095  " pltr is not supplied).\n"
22096  "\n"
22097  " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22098  " (inclusive) will be plotted.\n"
22099  "\n"
22100  " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22101  " values to use for value to color mappings. A datum equal to or\n"
22102  " less than valuemin will be plotted with color 0.0, while a datum\n"
22103  " equal to or greater than valuemax will be plotted with color 1.0.\n"
22104  " Data between valuemin and valuemax map linearly to colors in the\n"
22105  " range (0.0-1.0).\n"
22106  "\n"
22107  " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22108  " defines the transformation between the zero-based indices of the\n"
22109  " matrix idata and world coordinates. If\n"
22110  " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22111  " indices of idata are mapped to the range\n"
22112  " xmin through\n"
22113  " xmax and the y indices of idata are mapped to the range\n"
22114  " ymin through\n"
22115  " ymax.For the C case, transformation functions are provided in the\n"
22116  " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22117  " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22118  " matrices. In addition, C callback routines for the transformation\n"
22119  " can be supplied by the user such as the mypltr function in\n"
22120  " examples/c/x09c.c which provides a general linear transformation\n"
22121  " between index coordinates and world coordinates.For languages\n"
22122  " other than C you should consult the PLplot documentation for the\n"
22123  " details concerning how PLTRANSFORM_callback arguments are\n"
22124  " interfaced. However, in general, a particular pattern of\n"
22125  " callback-associated arguments such as a tr vector with 6 elements;\n"
22126  " xg and yg vectors; or xg and yg matrices are respectively\n"
22127  " interfaced to a linear-transformation routine similar to the above\n"
22128  " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22129  " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22130  " support native language callbacks for handling index to\n"
22131  " world-coordinate transformations. Examples of these various\n"
22132  " approaches are given in examples/<language>x09*,\n"
22133  " examples/<language>x16*, examples/<language>x20*,\n"
22134  " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22135  " supported languages.\n"
22136  "\n"
22137  " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22138  " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22139  " externally supplied.\n"
22140  "\n"
22141  ""},
22142  { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22143  { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22144  { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22145  { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22146  { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22147  { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22148  "Wait for graphics input event and translate to world coordinates.\n"
22149  "\n"
22150  "DESCRIPTION:\n"
22151  "\n"
22152  " Wait for graphics input event and translate to world coordinates.\n"
22153  " Returns 0 if no translation to world coordinates is possible.\n"
22154  "\n"
22155  " This function returns 1 on success and 0 if no translation to world\n"
22156  " coordinates is possible.\n"
22157  "\n"
22158  " Redacted form: plGetCursor(gin)\n"
22159  "\n"
22160  " This function is used in examples 1 and 20.\n"
22161  "\n"
22162  "\n"
22163  "\n"
22164  "SYNOPSIS:\n"
22165  "\n"
22166  "PLINT plGetCursor(gin)\n"
22167  "\n"
22168  "ARGUMENTS:\n"
22169  "\n"
22170  " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22171  " which will contain the output. The structure is not allocated by\n"
22172  " the routine and must exist before the function is called.\n"
22173  "\n"
22174  ""},
22175  { NULL, NULL, 0, NULL }
22176 };
22177 
22178 static PyMethodDef SwigMethods_proxydocs[] = {
22179  { NULL, NULL, 0, NULL }
22180 };
22181 
22182 
22183 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22184 
22185 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22186 static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22187 static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22188 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22189 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22190 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};
22191 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};
22192 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};
22193 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};
22194 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};
22195 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22196 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22197 static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22198 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22199 
22204  &_swigt__p_char,
22211  &_swigt__p_int,
22215 };
22216 
22217 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22218 static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22219 static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22220 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22221 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22227 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22228 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22229 static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22230 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22231 
22243  _swigc__p_int,
22247 };
22248 
22249 
22250 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22251 
22253 {0, 0, 0, 0.0, 0, 0}};
22254 
22255 #ifdef __cplusplus
22256 }
22257 #endif
22258 /* -----------------------------------------------------------------------------
22259  * Type initialization:
22260  * This problem is tough by the requirement that no dynamic
22261  * memory is used. Also, since swig_type_info structures store pointers to
22262  * swig_cast_info structures and swig_cast_info structures store pointers back
22263  * to swig_type_info structures, we need some lookup code at initialization.
22264  * The idea is that swig generates all the structures that are needed.
22265  * The runtime then collects these partially filled structures.
22266  * The SWIG_InitializeModule function takes these initial arrays out of
22267  * swig_module, and does all the lookup, filling in the swig_module.types
22268  * array with the correct data and linking the correct swig_cast_info
22269  * structures together.
22270  *
22271  * The generated swig_type_info structures are assigned statically to an initial
22272  * array. We just loop through that array, and handle each type individually.
22273  * First we lookup if this type has been already loaded, and if so, use the
22274  * loaded structure instead of the generated one. Then we have to fill in the
22275  * cast linked list. The cast data is initially stored in something like a
22276  * two-dimensional array. Each row corresponds to a type (there are the same
22277  * number of rows as there are in the swig_type_initial array). Each entry in
22278  * a column is one of the swig_cast_info structures for that type.
22279  * The cast_initial array is actually an array of arrays, because each row has
22280  * a variable number of columns. So to actually build the cast linked list,
22281  * we find the array of casts associated with the type, and loop through it
22282  * adding the casts to the list. The one last trick we need to do is making
22283  * sure the type pointer in the swig_cast_info struct is correct.
22284  *
22285  * First off, we lookup the cast->type name to see if it is already loaded.
22286  * There are three cases to handle:
22287  * 1) If the cast->type has already been loaded AND the type we are adding
22288  * casting info to has not been loaded (it is in this module), THEN we
22289  * replace the cast->type pointer with the type pointer that has already
22290  * been loaded.
22291  * 2) If BOTH types (the one we are adding casting info to, and the
22292  * cast->type) are loaded, THEN the cast info has already been loaded by
22293  * the previous module so we just ignore it.
22294  * 3) Finally, if cast->type has not already been loaded, then we add that
22295  * swig_cast_info to the linked list (because the cast->type) pointer will
22296  * be correct.
22297  * ----------------------------------------------------------------------------- */
22298 
22299 #ifdef __cplusplus
22300 extern "C" {
22301 #if 0
22302 } /* c-mode */
22303 #endif
22304 #endif
22305 
22306 #if 0
22307 #define SWIGRUNTIME_DEBUG
22308 #endif
22309 
22310 
22311 SWIGRUNTIME void
22312 SWIG_InitializeModule(void *clientdata) {
22313  size_t i;
22314  swig_module_info *module_head, *iter;
22315  int init;
22316 
22317  /* check to see if the circular list has been setup, if not, set it up */
22318  if (swig_module.next==0) {
22319  /* Initialize the swig_module */
22323  init = 1;
22324  } else {
22325  init = 0;
22326  }
22327 
22328  /* Try and load any already created modules */
22329  module_head = SWIG_GetModule(clientdata);
22330  if (!module_head) {
22331  /* This is the first module loaded for this interpreter */
22332  /* so set the swig module into the interpreter */
22333  SWIG_SetModule(clientdata, &swig_module);
22334  } else {
22335  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22336  iter=module_head;
22337  do {
22338  if (iter==&swig_module) {
22339  /* Our module is already in the list, so there's nothing more to do. */
22340  return;
22341  }
22342  iter=iter->next;
22343  } while (iter!= module_head);
22344 
22345  /* otherwise we must add our module into the list */
22346  swig_module.next = module_head->next;
22347  module_head->next = &swig_module;
22348  }
22349 
22350  /* When multiple interpreters are used, a module could have already been initialized in
22351  a different interpreter, but not yet have a pointer in this interpreter.
22352  In this case, we do not want to continue adding types... everything should be
22353  set up already */
22354  if (init == 0) return;
22355 
22356  /* Now work on filling in swig_module.types */
22357 #ifdef SWIGRUNTIME_DEBUG
22358  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
22359 #endif
22360  for (i = 0; i < swig_module.size; ++i) {
22361  swig_type_info *type = 0;
22362  swig_type_info *ret;
22363  swig_cast_info *cast;
22364 
22365 #ifdef SWIGRUNTIME_DEBUG
22366  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22367 #endif
22368 
22369  /* if there is another module already loaded */
22370  if (swig_module.next != &swig_module) {
22372  }
22373  if (type) {
22374  /* Overwrite clientdata field */
22375 #ifdef SWIGRUNTIME_DEBUG
22376  printf("SWIG_InitializeModule: found type %s\n", type->name);
22377 #endif
22380 #ifdef SWIGRUNTIME_DEBUG
22381  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22382 #endif
22383  }
22384  } else {
22385  type = swig_module.type_initial[i];
22386  }
22387 
22388  /* Insert casting types */
22389  cast = swig_module.cast_initial[i];
22390  while (cast->type) {
22391  /* Don't need to add information already in the list */
22392  ret = 0;
22393 #ifdef SWIGRUNTIME_DEBUG
22394  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22395 #endif
22396  if (swig_module.next != &swig_module) {
22398 #ifdef SWIGRUNTIME_DEBUG
22399  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22400 #endif
22401  }
22402  if (ret) {
22403  if (type == swig_module.type_initial[i]) {
22404 #ifdef SWIGRUNTIME_DEBUG
22405  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22406 #endif
22407  cast->type = ret;
22408  ret = 0;
22409  } else {
22410  /* Check for casting already in the list */
22411  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22412 #ifdef SWIGRUNTIME_DEBUG
22413  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22414 #endif
22415  if (!ocast) ret = 0;
22416  }
22417  }
22418 
22419  if (!ret) {
22420 #ifdef SWIGRUNTIME_DEBUG
22421  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22422 #endif
22423  if (type->cast) {
22424  type->cast->prev = cast;
22425  cast->next = type->cast;
22426  }
22427  type->cast = cast;
22428  }
22429  cast++;
22430  }
22431  /* Set entry in modules->types array equal to the type */
22432  swig_module.types[i] = type;
22433  }
22434  swig_module.types[i] = 0;
22435 
22436 #ifdef SWIGRUNTIME_DEBUG
22437  printf("**** SWIG_InitializeModule: Cast List ******\n");
22438  for (i = 0; i < swig_module.size; ++i) {
22439  int j = 0;
22441  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22442  while (cast->type) {
22443  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22444  cast++;
22445  ++j;
22446  }
22447  printf("---- Total casts: %d\n",j);
22448  }
22449  printf("**** SWIG_InitializeModule: Cast List ******\n");
22450 #endif
22451 }
22452 
22453 /* This function will propagate the clientdata field of type to
22454 * any new swig_type_info structures that have been added into the list
22455 * of equivalent types. It is like calling
22456 * SWIG_TypeClientData(type, clientdata) a second time.
22457 */
22458 SWIGRUNTIME void
22460  size_t i;
22461  swig_cast_info *equiv;
22462  static int init_run = 0;
22463 
22464  if (init_run) return;
22465  init_run = 1;
22466 
22467  for (i = 0; i < swig_module.size; i++) {
22468  if (swig_module.types[i]->clientdata) {
22469  equiv = swig_module.types[i]->cast;
22470  while (equiv) {
22471  if (!equiv->converter) {
22472  if (equiv->type && !equiv->type->clientdata)
22474  }
22475  equiv = equiv->next;
22476  }
22477  }
22478  }
22479 }
22480 
22481 #ifdef __cplusplus
22482 #if 0
22483 {
22484  /* c-mode */
22485 #endif
22486 }
22487 #endif
22488 
22489 
22490 
22491 #ifdef __cplusplus
22492 extern "C" {
22493 #endif
22494 
22495  /* Python-specific SWIG API */
22496 #define SWIG_newvarlink() SWIG_Python_newvarlink()
22497 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22498 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22499 
22500  /* -----------------------------------------------------------------------------
22501  * global variable support code.
22502  * ----------------------------------------------------------------------------- */
22503 
22504  typedef struct swig_globalvar {
22505  char *name; /* Name of global variable */
22506  PyObject *(*get_attr)(void); /* Return the current value */
22507  int (*set_attr)(PyObject *); /* Set the value */
22509  } swig_globalvar;
22510 
22511  typedef struct swig_varlinkobject {
22512  PyObject_HEAD
22515 
22516  SWIGINTERN PyObject *
22518 #if PY_VERSION_HEX >= 0x03000000
22519  return PyUnicode_InternFromString("<Swig global variables>");
22520 #else
22521  return PyString_FromString("<Swig global variables>");
22522 #endif
22523  }
22524 
22525  SWIGINTERN PyObject *
22527 #if PY_VERSION_HEX >= 0x03000000
22528  PyObject *str = PyUnicode_InternFromString("(");
22529  PyObject *tail;
22530  PyObject *joined;
22531  swig_globalvar *var;
22532  for (var = v->vars; var; var=var->next) {
22533  tail = PyUnicode_FromString(var->name);
22534  joined = PyUnicode_Concat(str, tail);
22535  Py_DecRef(str);
22536  Py_DecRef(tail);
22537  str = joined;
22538  if (var->next) {
22539  tail = PyUnicode_InternFromString(", ");
22540  joined = PyUnicode_Concat(str, tail);
22541  Py_DecRef(str);
22542  Py_DecRef(tail);
22543  str = joined;
22544  }
22545  }
22546  tail = PyUnicode_InternFromString(")");
22547  joined = PyUnicode_Concat(str, tail);
22548  Py_DecRef(str);
22549  Py_DecRef(tail);
22550  str = joined;
22551 #else
22552  PyObject *str = PyString_FromString("(");
22553  swig_globalvar *var;
22554  for (var = v->vars; var; var=var->next) {
22555  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22556  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22557  }
22558  PyString_ConcatAndDel(&str,PyString_FromString(")"));
22559 #endif
22560  return str;
22561  }
22562 
22563  SWIGINTERN void
22565  swig_globalvar *var = v->vars;
22566  while (var) {
22567  swig_globalvar *n = var->next;
22568  free(var->name);
22569  free(var);
22570  var = n;
22571  }
22572  }
22573 
22574  SWIGINTERN PyObject *
22576  PyObject *res = NULL;
22577  swig_globalvar *var = v->vars;
22578  while (var) {
22579  if (strcmp(var->name,n) == 0) {
22580  res = (*var->get_attr)();
22581  break;
22582  }
22583  var = var->next;
22584  }
22585  if (res == NULL && !PyErr_Occurred()) {
22586  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22587  }
22588  return res;
22589  }
22590 
22591  SWIGINTERN int
22592  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22593  int res = 1;
22594  swig_globalvar *var = v->vars;
22595  while (var) {
22596  if (strcmp(var->name,n) == 0) {
22597  res = (*var->set_attr)(p);
22598  break;
22599  }
22600  var = var->next;
22601  }
22602  if (res == 1 && !PyErr_Occurred()) {
22603  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22604  }
22605  return res;
22606  }
22607 
22608  SWIGINTERN PyTypeObject*
22610  static char varlink__doc__[] = "Swig var link object";
22611  static PyTypeObject varlink_type;
22612  static int type_init = 0;
22613  if (!type_init) {
22614  const PyTypeObject tmp = {
22615 #if PY_VERSION_HEX >= 0x03000000
22616  PyVarObject_HEAD_INIT(NULL, 0)
22617 #else
22618  PyObject_HEAD_INIT(NULL)
22619  0, /* ob_size */
22620 #endif
22621  "swigvarlink", /* tp_name */
22622  sizeof(swig_varlinkobject), /* tp_basicsize */
22623  0, /* tp_itemsize */
22624  (destructor) swig_varlink_dealloc, /* tp_dealloc */
22625  0, /* tp_print */
22626  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22627  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22628  0, /* tp_compare */
22629  (reprfunc) swig_varlink_repr, /* tp_repr */
22630  0, /* tp_as_number */
22631  0, /* tp_as_sequence */
22632  0, /* tp_as_mapping */
22633  0, /* tp_hash */
22634  0, /* tp_call */
22635  (reprfunc) swig_varlink_str, /* tp_str */
22636  0, /* tp_getattro */
22637  0, /* tp_setattro */
22638  0, /* tp_as_buffer */
22639  0, /* tp_flags */
22640  varlink__doc__, /* tp_doc */
22641  0, /* tp_traverse */
22642  0, /* tp_clear */
22643  0, /* tp_richcompare */
22644  0, /* tp_weaklistoffset */
22645  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22646  0, /* tp_del */
22647  0, /* tp_version_tag */
22648 #if PY_VERSION_HEX >= 0x03040000
22649  0, /* tp_finalize */
22650 #endif
22651 #ifdef COUNT_ALLOCS
22652  0, /* tp_allocs */
22653  0, /* tp_frees */
22654  0, /* tp_maxalloc */
22655  0, /* tp_prev */
22656  0 /* tp_next */
22657 #endif
22658  };
22659  varlink_type = tmp;
22660  type_init = 1;
22661  if (PyType_Ready(&varlink_type) < 0)
22662  return NULL;
22663  }
22664  return &varlink_type;
22665  }
22666 
22667  /* Create a variable linking object for use later */
22668  SWIGINTERN PyObject *
22670  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22671  if (result) {
22672  result->vars = 0;
22673  }
22674  return ((PyObject*) result);
22675  }
22676 
22677  SWIGINTERN void
22678  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22680  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22681  if (gv) {
22682  size_t size = strlen(name)+1;
22683  gv->name = (char *)malloc(size);
22684  if (gv->name) {
22685  memcpy(gv->name, name, size);
22686  gv->get_attr = get_attr;
22687  gv->set_attr = set_attr;
22688  gv->next = v->vars;
22689  }
22690  }
22691  v->vars = gv;
22692  }
22693 
22694  SWIGINTERN PyObject *
22696  static PyObject *globals = 0;
22697  if (!globals) {
22698  globals = SWIG_newvarlink();
22699  }
22700  return globals;
22701  }
22702 
22703  /* -----------------------------------------------------------------------------
22704  * constants/methods manipulation
22705  * ----------------------------------------------------------------------------- */
22706 
22707  /* Install Constants */
22708  SWIGINTERN void
22709  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
22710  PyObject *obj = 0;
22711  size_t i;
22712  for (i = 0; constants[i].type; ++i) {
22713  switch(constants[i].type) {
22714  case SWIG_PY_POINTER:
22715  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22716  break;
22717  case SWIG_PY_BINARY:
22718  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22719  break;
22720  default:
22721  obj = 0;
22722  break;
22723  }
22724  if (obj) {
22725  PyDict_SetItemString(d, constants[i].name, obj);
22726  Py_DECREF(obj);
22727  }
22728  }
22729  }
22730 
22731  /* -----------------------------------------------------------------------------*/
22732  /* Fix SwigMethods to carry the callback ptrs when needed */
22733  /* -----------------------------------------------------------------------------*/
22734 
22735  SWIGINTERN void
22736  SWIG_Python_FixMethods(PyMethodDef *methods,
22737  swig_const_info *const_table,
22738  swig_type_info **types,
22739  swig_type_info **types_initial) {
22740  size_t i;
22741  for (i = 0; methods[i].ml_name; ++i) {
22742  const char *c = methods[i].ml_doc;
22743  if (!c) continue;
22744  c = strstr(c, "swig_ptr: ");
22745  if (c) {
22746  int j;
22747  swig_const_info *ci = 0;
22748  const char *name = c + 10;
22749  for (j = 0; const_table[j].type; ++j) {
22750  if (strncmp(const_table[j].name, name,
22751  strlen(const_table[j].name)) == 0) {
22752  ci = &(const_table[j]);
22753  break;
22754  }
22755  }
22756  if (ci) {
22757  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22758  if (ptr) {
22759  size_t shift = (ci->ptype) - types;
22760  swig_type_info *ty = types_initial[shift];
22761  size_t ldoc = (c - methods[i].ml_doc);
22762  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22763  char *ndoc = (char*)malloc(ldoc + lptr + 10);
22764  if (ndoc) {
22765  char *buff = ndoc;
22766  memcpy(buff, methods[i].ml_doc, ldoc);
22767  buff += ldoc;
22768  memcpy(buff, "swig_ptr: ", 10);
22769  buff += 10;
22770  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22771  methods[i].ml_doc = ndoc;
22772  }
22773  }
22774  }
22775  }
22776  }
22777  }
22778 
22779  /* -----------------------------------------------------------------------------
22780  * Method creation and docstring support functions
22781  * ----------------------------------------------------------------------------- */
22782 
22783  /* -----------------------------------------------------------------------------
22784  * Function to find the method definition with the correct docstring for the
22785  * proxy module as opposed to the low-level API
22786  * ----------------------------------------------------------------------------- */
22787 
22788  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
22789  /* Find the function in the modified method table */
22790  size_t offset = 0;
22791  int found = 0;
22792  while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
22793  if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
22794  found = 1;
22795  break;
22796  }
22797  offset++;
22798  }
22799  /* Use the copy with the modified docstring if available */
22800  return found ? &SwigMethods_proxydocs[offset] : NULL;
22801  }
22802 
22803  /* -----------------------------------------------------------------------------
22804  * Wrapper of PyInstanceMethod_New() used in Python 3
22805  * It is exported to the generated module, used for -fastproxy
22806  * ----------------------------------------------------------------------------- */
22807 
22808  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22809  if (PyCFunction_Check(func)) {
22810  PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22811  PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22812  if (ml)
22813  func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22814  }
22815 #if PY_VERSION_HEX >= 0x03000000
22816  return PyInstanceMethod_New(func);
22817 #else
22818  return PyMethod_New(func, NULL, NULL);
22819 #endif
22820  }
22821 
22822  /* -----------------------------------------------------------------------------
22823  * Wrapper of PyStaticMethod_New()
22824  * It is exported to the generated module, used for -fastproxy
22825  * ----------------------------------------------------------------------------- */
22826 
22827  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22828  if (PyCFunction_Check(func)) {
22829  PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22830  PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22831  if (ml)
22832  func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22833  }
22834  return PyStaticMethod_New(func);
22835  }
22836 
22837 #ifdef __cplusplus
22838 }
22839 #endif
22840 
22841 /* -----------------------------------------------------------------------------*
22842  * Partial Init method
22843  * -----------------------------------------------------------------------------*/
22844 
22845 #ifdef __cplusplus
22846 extern "C"
22847 #endif
22848 
22849 SWIGEXPORT
22850 #if PY_VERSION_HEX >= 0x03000000
22851 PyObject*
22852 #else
22853 void
22854 #endif
22855 SWIG_init(void) {
22856  PyObject *m, *d, *md, *globals;
22857 
22858 #if PY_VERSION_HEX >= 0x03000000
22859  static struct PyModuleDef SWIG_module = {
22860  PyModuleDef_HEAD_INIT,
22861  SWIG_name,
22862  NULL,
22863  -1,
22864  SwigMethods,
22865  NULL,
22866  NULL,
22867  NULL,
22868  NULL
22869  };
22870 #endif
22871 
22872 #if defined(SWIGPYTHON_BUILTIN)
22873  static SwigPyClientData SwigPyObject_clientdata = {
22874  0, 0, 0, 0, 0, 0, 0
22875  };
22876  static PyGetSetDef this_getset_def = {
22877  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22878  };
22879  static SwigPyGetSet thisown_getset_closure = {
22882  };
22883  static PyGetSetDef thisown_getset_def = {
22884  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22885  };
22886  PyTypeObject *builtin_pytype;
22887  int builtin_base_count;
22888  swig_type_info *builtin_basetype;
22889  PyObject *tuple;
22890  PyGetSetDescrObject *static_getset;
22891  PyTypeObject *metatype;
22892  PyTypeObject *swigpyobject;
22893  SwigPyClientData *cd;
22894  PyObject *public_interface, *public_symbol;
22895  PyObject *this_descr;
22896  PyObject *thisown_descr;
22897  PyObject *self = 0;
22898  int i;
22899 
22900  (void)builtin_pytype;
22901  (void)builtin_base_count;
22902  (void)builtin_basetype;
22903  (void)tuple;
22904  (void)static_getset;
22905  (void)self;
22906 
22907  /* Metaclass is used to implement static member variables */
22908  metatype = SwigPyObjectType();
22909  assert(metatype);
22910 #endif
22911 
22912  (void)globals;
22913 
22914  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
22915  SWIG_This();
22918 #ifndef SWIGPYTHON_BUILTIN
22920 #endif
22921 
22922  /* Fix SwigMethods to carry the callback ptrs when needed */
22924 
22925 #if PY_VERSION_HEX >= 0x03000000
22926  m = PyModule_Create(&SWIG_module);
22927 #else
22928  m = Py_InitModule(SWIG_name, SwigMethods);
22929 #endif
22930 
22931  md = d = PyModule_GetDict(m);
22932  (void)md;
22933 
22935 
22936 #ifdef SWIGPYTHON_BUILTIN
22937  swigpyobject = SwigPyObject_TypeOnce();
22938 
22939  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
22940  assert(SwigPyObject_stype);
22941  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
22942  if (!cd) {
22943  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
22944  SwigPyObject_clientdata.pytype = swigpyobject;
22945  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
22946  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
22947 # if PY_VERSION_HEX >= 0x03000000
22948  return NULL;
22949 # else
22950  return;
22951 # endif
22952  }
22953 
22954  /* All objects have a 'this' attribute */
22955  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
22956  (void)this_descr;
22957 
22958  /* All objects have a 'thisown' attribute */
22959  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
22960  (void)thisown_descr;
22961 
22962  public_interface = PyList_New(0);
22963  public_symbol = 0;
22964  (void)public_symbol;
22965 
22966  PyDict_SetItemString(md, "__all__", public_interface);
22967  Py_DECREF(public_interface);
22968  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
22969  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
22970  for (i = 0; swig_const_table[i].name != 0; ++i)
22971  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
22972 #endif
22973 
22975 
22976 
22977  import_array();
22978 
22979  SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
22980  SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
22981  SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
22982  SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
22983  SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
22984  SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
22985  SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
22986  SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
22987  SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
22988  SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
22989  SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
22990  SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
22991  SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
22992  SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
22993  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
22994  SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
22995  SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
22996  SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
22997  SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
22998  SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
22999  SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23000  SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23001  SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23002  SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23003  SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23004  SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23005  SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23006  SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23007  SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23008  SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23009  SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23010  SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23011  SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23012  SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23013  SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23014  SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23015  SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23016  SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23017  SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23018  SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23019  SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23020  SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23021  SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23022  SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23023  SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23024  SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23025  SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23026  SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23027  SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23028  SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23029  SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23030  SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23031  SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23032  SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23033  SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23034  SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23035  SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23036  SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23037  SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23038  SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23039  SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23040  SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23041  SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23042  SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23043  SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23044  SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23045  SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23046  SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23047  SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23048  SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23049  SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23050  SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23051  SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23052  SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23053  SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23054  SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23055  SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23056  SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23057  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23058  SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23059  SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23060  SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23061  SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23062  SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23063  SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23064  SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23065  SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23066  SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23067  SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23068  SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23069  SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23070  SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23071  SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23072  SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23073  SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23074  SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23075  SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23076  SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23077  SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23078  SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23079  SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23080  SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23081  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23082  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23083  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23084  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23085  SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23086  SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23087  SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23088  SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23089  SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23090  SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23091  SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23092  SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23093  SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23094  SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23095  SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23096  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23097  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23098  SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23099  SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23100  SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23101  SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23102  SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23103  SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23104  SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23105  SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23106  SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23107  SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23108  SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23109  SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23110  SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23111  SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23112  SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23113  SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23114  SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23115  SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23116  SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23117  SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23118  SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23119  SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23120  SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23121  SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23122  SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23123  SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23124  SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23125  SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23126  SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23127  SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23128  SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23129  SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23130  SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23131  SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23132  SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23133  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23134  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23135  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23136  SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23137  SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23138  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23139  SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23140  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23141  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23142  SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23143  SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23144  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23145  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23146  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23147  SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23148  SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23149  SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23150  SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23151  SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23152  SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23153  SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23154  SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23155  SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23156  SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23157  SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23158  SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23159  SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23160  SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23161  SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23162  SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23163  SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23164 #if PY_VERSION_HEX >= 0x03000000
23165  return m;
23166 #else
23167  return;
23168 #endif
23169 }
23170 
pllsty
#define pllsty
Definition: plplot.h:763
_wrap_plgpage
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6733
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:22736
SWIG_globals
SWIGINTERN PyObject * SWIG_globals(void)
Definition: plplotcPYTHON_wrap.c:22695
swig_const_info::pvalue
void * pvalue
Definition: plplotcPYTHON_wrap.c:1028
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotcPYTHON_wrap.c:2757
_wrap_plsesc
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11164
plsstrm
#define plsstrm
Definition: plplot.h:835
_wrap_plbin
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4850
_wrap_plvect
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13086
plsdidev
#define plsdidev
Definition: plplot.h:807
_wrap_plpat
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9349
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplotcPYTHON_wrap.c:22220
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:3999
SWIG_Python_NewPointerObj
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
Definition: plplotcPYTHON_wrap.c:2294
plshade
#define plshade
Definition: plplot.h:820
_wrap_PLGraphicsIn_string_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4155
marshal_mapform
mapform_func marshal_mapform(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3832
plsurf3d
#define plsurf3d
Definition: plplot.h:847
_wrap_plend
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5644
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:4422
plssym
#define plssym
Definition: plplot.h:837
NPY_PLFLT
#define NPY_PLFLT
Definition: plplotcPYTHON_wrap.c:2692
plinit
#define plinit
Definition: plplot.h:755
_wrap_plpsty
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9704
_wrap_plsdidev
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10924
_wrap_pladv
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4668
SwigPyObject_hex
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1410
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:3676
_wrap_plgvpd
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7050
_wrap_plspage
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11933
_wrap_plmeshc
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8488
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:22507
swig_cast_info
struct swig_cast_info swig_cast_info
_wrap_plscmap1la
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10460
plerry
#define plerry
Definition: plplot.h:715
SWIG_Python_SetErrorObj
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1108
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:2651
_wrap_plsfam
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11222
_wrap_plgxax
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7154
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:4561
plptex3
#define plptex3
Definition: plplot.h:786
_wrap_plscmap1a
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10260
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:22200
SWIG_PY_POINTER
#define SWIG_PY_POINTER
Definition: plplotcPYTHON_wrap.c:1019
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:10170
_wrap_plseed
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11142
plgspa
#define plgspa
Definition: plplot.h:743
SwigMethods
static PyMethodDef SwigMethods[]
Definition: plplotcPYTHON_wrap.c:14541
_wrap_plscolbg
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10773
_wrap_plend1
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5656
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:3348
swig_globalvar
struct swig_globalvar swig_globalvar
_wrap_pljoin
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7390
_wrap_plspause
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12051
plstart
#define plstart
Definition: plplot.h:839
plgcolbg
#define plgcolbg
Definition: plplot.h:726
marshal_ct
ct_func marshal_ct(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3817
cleanup_PLcGrid1
void cleanup_PLcGrid1(void)
Definition: plplotcPYTHON_wrap.c:3280
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:2348
swig_globalvar::get_attr
PyObject *(* get_attr)(void)
Definition: plplotcPYTHON_wrap.c:22506
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:4080
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:1265
_wrap_plline
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8271
_wrap_plsetopt
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11186
SWIG_PyStaticMethod_New
SWIGINTERN PyObject * SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
Definition: plplotcPYTHON_wrap.c:22827
cleanup_mapform
void cleanup_mapform(void)
Definition: plplotcPYTHON_wrap.c:3840
SWIG_NewPointerObj
#define SWIG_NewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1064
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:4185
tmpGrid1
static PLcGrid tmpGrid1
Definition: plplotcPYTHON_wrap.c:3232
_wrap_plmesh
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8408
_wrap_plsdiplz
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11097
SWIG_AsVal_double
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
Definition: plplotcPYTHON_wrap.c:2707
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:6510
pllab
#define pllab
Definition: plplot.h:757
_swigt__p_p_double
static swig_type_info _swigt__p_p_double
Definition: plplotcPYTHON_wrap.c:22197
_wrap_plOptUsage
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14448
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
SWIG_UnpackVoidPtr
const SWIGRUNTIME char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplotcPYTHON_wrap.c:687
_wrap_plstyl
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12718
plarc
#define plarc
Definition: plplot.h:693
plprec
#define plprec
Definition: plplot.h:783
_wrap_plwind
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13440
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:9506
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:3177
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:11052
_wrap_plctime
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5544
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:4103
do_pltr_callback
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3519
pllegend
#define pllegend
Definition: plplot.h:758
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplotcPYTHON_wrap.c:22221
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:12450
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:3976
SWIG_AsVal_unsigned_SS_int
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
Definition: plplotcPYTHON_wrap.c:2925
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:807
MY_BLOCK_THREADS
#define MY_BLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3497
SwigPyClientData_New
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1293
_wrap_plrandd
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9894
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:22192
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:8234
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:2181
_wrap_plmkstrm
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8584
SwigPyObject::own
int own
Definition: plplotcPYTHON_wrap.c:1351
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:1058
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:6119
swig_type_info
struct swig_type_info swig_type_info
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
SWIG_as_voidptrptr
#define SWIG_as_voidptrptr(a)
Definition: plplotcPYTHON_wrap.c:2679
SWIG_BUILTIN_TP_INIT
#define SWIG_BUILTIN_TP_INIT
Definition: plplotcPYTHON_wrap.c:1245
SWIG_Python_CallFunctor
#define SWIG_Python_CallFunctor(functor, obj)
Definition: plplotcPYTHON_wrap.c:1223
SwigPyPacked_compare
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
Definition: plplotcPYTHON_wrap.c:1798
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:13517
PySequence_Size
#define PySequence_Size
Definition: plplotcPYTHON_wrap.c:2699
plvpor
#define plvpor
Definition: plplot.h:860
marshal_PLPointer
PLPointer marshal_PLPointer(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3846
swig_varlink_repr
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
Definition: plplotcPYTHON_wrap.c:22517
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
_wrap_plbox
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5000
NPY_PLINT
#define NPY_PLINT
Definition: plplotcPYTHON_wrap.c:2687
_wrap_plot3dc
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8812
swig_varlinkobject
struct swig_varlinkobject swig_varlinkobject
_wrap_plbop
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4988
swig_globalvar
Definition: plplotcPYTHON_wrap.c:22504
_wrap_plgcolbga
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6363
SWIG_Python_InstallConstants
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
Definition: plplotcPYTHON_wrap.c:22709
plgyax
#define plgyax
Definition: plplot.h:749
plcol1
#define plcol1
Definition: plplot.h:703
CB_0
Definition: plplotcPYTHON_wrap.c:3475
marshal_pltr
pltr_func marshal_pltr(PyObject *input)
Definition: plplotcPYTHON_wrap.c:3758
plgvpd
#define plgvpd
Definition: plplot.h:746
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotcPYTHON_wrap.c:2759
_wrap_plsdev
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10899
SWIG_Python_CheckImplicit
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:1275
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:1349
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:6207
pltr_xg
PyArrayObject * pltr_xg
Definition: plplotcPYTHON_wrap.c:3231
_wrap_plsvpa
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12839
_wrap_plinit
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7378
_wrap_plmapline
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13596
_wrap_PLGraphicsIn_type_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3895
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:9397
SWIG_Python_ExceptionType
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
Definition: plplotcPYTHON_wrap.c:1285
_wrap_plptex
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9726
_wrap_pltimefmt
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13039
python_label
PyObject * python_label
Definition: plplotcPYTHON_wrap.c:3480
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:22564
_wrap_plhist
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7250
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplotcPYTHON_wrap.c:22188
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:8724
plgradient
#define plgradient
Definition: plplot.h:741
SwigPyPacked::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:1771
plgdiori
#define plgdiori
Definition: plplot.h:731
_wrap_plscompression
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10877
_wrap_plscmap1_range
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10614
SWIG_name
#define SWIG_name
Definition: plplotcPYTHON_wrap.c:2672
swig_varlink_setattr
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
Definition: plplotcPYTHON_wrap.c:22592
SWIG_FromCharPtrAndSize
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
Definition: plplotcPYTHON_wrap.c:3093
SwigPyObject_compare
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
Definition: plplotcPYTHON_wrap.c:1443
CB_2
Definition: plplotcPYTHON_wrap.c:3475
SWIG_InstallConstants
#define SWIG_InstallConstants(d, constants)
Definition: plplotcPYTHON_wrap.c:22498
SwigPyPacked_Check
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:1815
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
_wrap_plspal1
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12019
_wrap_PLGraphicsIn_wY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4503
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:333
swig_varlinkobject
Definition: plplotcPYTHON_wrap.c:22511
SWIG_AsVal_long
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
Definition: plplotcPYTHON_wrap.c:2818
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:22186
plline3
#define plline3
Definition: plplot.h:762
SWIG_PY_BINARY
#define SWIG_PY_BINARY
Definition: plplotcPYTHON_wrap.c:1020
do_mapform_callback
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplotcPYTHON_wrap.c:3717
SWIG_init
#define SWIG_init
Definition: plplotcPYTHON_wrap.c:2669
_wrap_plglevel
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6711
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:1821
_wrap_plgcol0a
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6259
SwigPyObject_acquire
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1586
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:6458
plsfam
#define plsfam
Definition: plplot.h:816
swig_const_info::name
const char * name
Definition: plplotcPYTHON_wrap.c:1025
SWIG_Python_ConvertPtr
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1057
plsfnam
#define plsfnam
Definition: plplot.h:818
plflush
#define plflush
Definition: plplot.h:719
tmpGrid2
static PLcGrid2 tmpGrid2
Definition: plplotcPYTHON_wrap.c:3233
_wrap_new_PLGraphicsIn
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4526
swig_const_info::dvalue
double dvalue
Definition: plplotcPYTHON_wrap.c:1027
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:6131
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:2047
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:11306
plscolor
#define plscolor
Definition: plplot.h:804
_wrap_pltr2
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3409
error
static int error
Definition: plcont.c:61
_wrap_plSetUsage
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14413
Ylen
static PLINT Ylen
Definition: plplotcPYTHON_wrap.c:2703
SWIG_Python_AddErrMesg
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
Definition: plplotcPYTHON_wrap.c:2449
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:4028
_wrap_plslabelfunc
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11723
_swigt__p_f_double_double__int
static swig_type_info _swigt__p_f_double_double__int
Definition: plplotcPYTHON_wrap.c:22190
_swigc__p_p_double
static swig_cast_info _swigc__p_p_double[]
Definition: plplotcPYTHON_wrap.c:22229
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:2697
SWIG_Python_TypeQuery
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
Definition: plplotcPYTHON_wrap.c:2420
plgfont
#define plgfont
Definition: plplot.h:737
python_f2eval
PyObject * python_f2eval
Definition: plplotcPYTHON_wrap.c:3477
_wrap_plbtime
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4906
SwigPyClientData::implicitconv
int implicitconv
Definition: plplotcPYTHON_wrap.c:1270
_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:22194
SwigPyClientData::newraw
PyObject * newraw
Definition: plplotcPYTHON_wrap.c:1266
SWIG_POINTER_NEW
#define SWIG_POINTER_NEW
Definition: plplotcPYTHON_wrap.c:1241
plenv
#define plenv
Definition: plplot.h:711
SWIG_From_int
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
Definition: plplotcPYTHON_wrap.c:2765
SWIG_POINTER_NOSHADOW
#define SWIG_POINTER_NOSHADOW
Definition: plplotcPYTHON_wrap.c:1240
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:5067
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplotcPYTHON_wrap.c:22198
plscmap1a
#define plscmap1a
Definition: plplot.h:795
_wrap_plgfam
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6584
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplotcPYTHON_wrap.c:22189
plstyl
#define plstyl
Definition: plplot.h:846
_wrap_plgchr
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6175
SWIG_TypeQuery
#define SWIG_TypeQuery(name)
Definition: plplotcPYTHON_wrap.c:2660
SWIG_Python_TypeErrorOccurred
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:911
_wrap_plscmap1l
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10347
SWIG_TypeError
#define SWIG_TypeError
Definition: plplotcPYTHON_wrap.c:736
SwigPyPacked::size
size_t size
Definition: plplotcPYTHON_wrap.c:1772
swig_const_info::ptype
swig_type_info ** ptype
Definition: plplotcPYTHON_wrap.c:1029
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:11798
_wrap_plgdev
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6437
_wrap_plpoin
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9450
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplotcPYTHON_wrap.c:22195
_wrap_plMinMax2dGrid
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14460
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplotcPYTHON_wrap.c:22196
SWIG_Python_InitShadowInstance
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
Definition: plplotcPYTHON_wrap.c:2276
swig_cast_info
Definition: plplotluacLUA_wrap.c:339
SWIG_exception_fail
#define SWIG_exception_fail(code, msg)
Definition: plplotcPYTHON_wrap.c:2613
SWIG_Python_str_FromChar
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
Definition: plplotcPYTHON_wrap.c:812
_wrap_plvsta
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13305
_wrap_plparseopts
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9282
_wrap_plfill3
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5996
_wrap_plfontld
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6153
plgdev
#define plgdev
Definition: plplot.h:729
_wrap_plmtex
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8606
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:2702
SWIGEXPORT
#define SWIGEXPORT
Definition: plplotcPYTHON_wrap.c:104
swig_varlink_type
SWIGINTERN PyTypeObject * swig_varlink_type(void)
Definition: plplotcPYTHON_wrap.c:22609
_wrap_plenv0
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5729
SwigPyObject_own
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
Definition: plplotcPYTHON_wrap.c:1594
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:1948
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:10192
SwigPyPacked_type
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
Definition: plplotcPYTHON_wrap.c:1809
SWIG_Python_SetErrorMsg
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
Definition: plplotcPYTHON_wrap.c:1116
_wrap_plscol0a
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10720
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplotcPYTHON_wrap.c:22230
_swigc__p_f_double_double__int
static swig_cast_info _swigc__p_f_double_double__int[]
Definition: plplotcPYTHON_wrap.c:22222
SwigPyPacked_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:1831
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplotcPYTHON_wrap.c:166
SWIG_UnpackData
const SWIGRUNTIME char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplotcPYTHON_wrap.c:648
_wrap_plsyax
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12913
plfill3
#define plfill3
Definition: plplot.h:718
swig_const_info
Definition: plplotcPYTHON_wrap.c:1023
_wrap_plsdimap
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10969
_wrap_plstring
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12268
plrgbhls
#define plrgbhls
Definition: plplot.h:789
PLGraphicsIn
Definition: plplot.h:433
SwigPyObject::ty
swig_type_info * ty
Definition: plplotcPYTHON_wrap.c:1350
SWIG_Python_MustGetPtr
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
Definition: plplotcPYTHON_wrap.c:2537
plszax
#define plszax
Definition: plplot.h:854
_wrap_plenv
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5668
pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
SWIG_TypePrettyName
const SWIGRUNTIME char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplotcPYTHON_wrap.c:507
SwigPyObject_New
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
Definition: plplotcPYTHON_wrap.c:1752
cleanup_PLcGrid2
void cleanup_PLcGrid2(void)
Definition: plplotcPYTHON_wrap.c:3339
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:11882
_swigc__p_PLcGrid2
static swig_cast_info _swigc__p_PLcGrid2[]
Definition: plplotcPYTHON_wrap.c:22219
_wrap_PLGraphicsIn_pY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4295
plsvect
#define plsvect
Definition: plplot.h:849
marshal_PLcGrid1
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3240
SWIG_Python_ConvertFunctionPtr
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:2152
_wrap_plmtex3
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8665
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
swig_const_table
static swig_const_info swig_const_table[]
Definition: plplotcPYTHON_wrap.c:22252
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:13699
plResetOpts
void plResetOpts(void)
Definition: plargs.c:843
python_ct
PyObject * python_ct
Definition: plplotcPYTHON_wrap.c:3478
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:11343
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:13207
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:6063
_wrap_pleop
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5790
SWIG_Py_Void
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
Definition: plplotcPYTHON_wrap.c:1255
SWIG_OK
#define SWIG_OK
Definition: plplotcPYTHON_wrap.c:287
_wrap_plerry
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5869
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:3871
plsori
#define plsori
Definition: plplot.h:830
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplotcPYTHON_wrap.c:1092
SWIG_NewClientData
#define SWIG_NewClientData(obj)
Definition: plplotcPYTHON_wrap.c:1094
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:22459
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
_swigt__p_PLcGrid2
static swig_type_info _swigt__p_PLcGrid2
Definition: plplotcPYTHON_wrap.c:22187
_wrap_plxormod
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13485
_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:22224
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:4539
_wrap_plstart
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12182
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:2755
plvsta
#define plvsta
Definition: plplot.h:861
SWIG_OverflowError
#define SWIG_OverflowError
Definition: plplotcPYTHON_wrap.c:738
swig_module_info
struct swig_module_info swig_module_info
_wrap_plsfnam
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11281
SwigPyPacked_UnpackData
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
Definition: plplotcPYTHON_wrap.c:1932
_wrap_plResetOpts
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14401
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:2396
SwigPyObject::next
PyObject * next
Definition: plplotcPYTHON_wrap.c:1352
PyObject_DEL
#define PyObject_DEL
Definition: plplotcPYTHON_wrap.c:822
SwigPyObject_GetDesc
const SWIGRUNTIMEINLINE char * SwigPyObject_GetDesc(PyObject *self)
Definition: plplotcPYTHON_wrap.c:2490
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:11840
SWIG_pchar_descriptor
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
Definition: plplotcPYTHON_wrap.c:2948
SwigPyObject_Check
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
Definition: plplotcPYTHON_wrap.c:1486
plscol0a
#define plscol0a
Definition: plplot.h:801
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:2636
pllightsource
#define pllightsource
Definition: plplot.h:759
_wrap_plmeridians
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14038
plshades
#define plshades
Definition: plplot.h:824
SWIG_TypeName
const SWIGRUNTIMEINLINE char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:498
SWIG_AsVal_unsigned_SS_long
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
Definition: plplotcPYTHON_wrap.c:2877
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:4266
SWIG_From_unsigned_SS_int
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
Definition: plplotcPYTHON_wrap.c:2941
t_output_helper
#define t_output_helper
Definition: plplotcPYTHON_wrap.c:3130
pltr_yg
PyArrayObject * pltr_yg
Definition: plplotcPYTHON_wrap.c:3231
SWIG_fail
#define SWIG_fail
Definition: plplotcPYTHON_wrap.c:1100
_wrap_PLGraphicsIn_dX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4318
SWIG_Python_SetSwigThis
SWIGRUNTIME void SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
Definition: plplotcPYTHON_wrap.c:2254
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:13260
_wrap_plsdiori
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11030
_wrap_plcalc_world
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5194
python_pltr
PyObject * python_pltr
Definition: plplotcPYTHON_wrap.c:3476
SWIG_PythonGetProxyDoc
SWIGINTERN PyMethodDef * SWIG_PythonGetProxyDoc(const char *name)
Definition: plplotcPYTHON_wrap.c:22788
SWIG_Python_TypeCache
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
Definition: plplotcPYTHON_wrap.c:2414
SWIG_POINTER_IMPLICIT_CONV
#define SWIG_POINTER_IMPLICIT_CONV
Definition: plplotcPYTHON_wrap.c:1243
_wrap_plimagefr
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14239
_wrap_PLGraphicsIn_pX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4243
_wrap_plstring3
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12327
_wrap_plclear
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5253
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:1156
_wrap_pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4594
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:10675
cleanup_pltr
void cleanup_pltr(void)
Definition: plplotcPYTHON_wrap.c:3810
SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
Definition: plplotcPYTHON_wrap.c:1000
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:13027
swig_types
static swig_type_info * swig_types[15]
Definition: plplotcPYTHON_wrap.c:2650
SwigPyPacked_New
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
Definition: plplotcPYTHON_wrap.c:1913
SWIG_AsCharArray
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
Definition: plplotcPYTHON_wrap.c:3068
plbox3
#define plbox3
Definition: plplot.h:698
_wrap_plgfnam
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6648
PLcGrid
Definition: plplot.h:506
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:2861
SWIG_SystemError
#define SWIG_SystemError
Definition: plplotcPYTHON_wrap.c:741
cleanup_ct
void cleanup_ct(void)
Definition: plplotcPYTHON_wrap.c:3825
_wrap_plscolbga
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10810
plreplot
#define plreplot
Definition: plplot.h:788
_wrap_plrgbhls
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9919
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:1339
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:1951
swig_const_info::lvalue
long lvalue
Definition: plplotcPYTHON_wrap.c:1026
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:22223
_wrap_plstransform
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12222
_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:22193
_wrap_pllegend
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7481
_wrap_plfill
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5948
SwigPyObject_format
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1382
SwigPyObject_disown
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1578
MY_UNBLOCK_THREADS
#define MY_UNBLOCK_THREADS
Definition: plplotcPYTHON_wrap.c:3498
_wrap_plimage
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14122
_wrap_plgyax
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7186
SwigMethods_proxydocs
static PyMethodDef SwigMethods_proxydocs[]
Definition: plplotcPYTHON_wrap.c:22178
_wrap_plgfont
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6669
_wrap_PLGraphicsIn_dY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4370
_wrap_plgcolbg
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6321
_wrap_plsurf3d
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9047
swig_const_info::type
int type
Definition: plplotcPYTHON_wrap.c:1024
SwigPyObject_TypeOnce
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
Definition: plplotcPYTHON_wrap.c:1625
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:3924
do_label_callback
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3619
_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:22191
marshal_PLcGrid2
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
Definition: plplotcPYTHON_wrap.c:3287
SwigPyObject_richcompare
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
Definition: plplotcPYTHON_wrap.c:1452
SwigPyObject_dealloc
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
Definition: plplotcPYTHON_wrap.c:1502
_wrap_plgcmap1_range
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10643
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:1093
SwigPyObject_next
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1566
_wrap_plhlsrgb
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7311
_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:22225
_wrap_plshade
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11517
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplotcPYTHON_wrap.c:329
SWIG_NewPackedObj
#define SWIG_NewPackedObj(ptr, sz, type)
Definition: plplotcPYTHON_wrap.c:1075
SWIG_Python_GetModule
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
Definition: plplotcPYTHON_wrap.c:2361
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:2961
_wrap_plsym
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12942
_wrap_plssym
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12124
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:10855
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:22505
_wrap_plw3d
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13317
PLcGrid2
Definition: plplot.h:518
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplotcPYTHON_wrap.c:22312
_wrap_plptex3
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9790
swig_globalvar::next
struct swig_globalvar * next
Definition: plplotcPYTHON_wrap.c:22508
SwigPyObject_append
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
Definition: plplotcPYTHON_wrap.c:1553
SWIG_Python_AddErrorMsg
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
Definition: plplotcPYTHON_wrap.c:885
plsesc
#define plsesc
Definition: plplot.h:814
_wrap_plsxwin
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4572
python_mapform
PyObject * python_mapform
Definition: plplotcPYTHON_wrap.c:3479
plptex
#define plptex
Definition: plplot.h:785
SWIG_as_voidptr
#define SWIG_as_voidptr(a)
Definition: plplotcPYTHON_wrap.c:2678
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:9143
_wrap_PLGraphicsIn_wY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4474
plscol0
#define plscol0
Definition: plplot.h:800
SwigPyPacked::pack
PyObject_HEAD void * pack
Definition: plplotcPYTHON_wrap.c:1770
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:4132
callback_type
callback_type
Definition: plplotcPYTHON_wrap.c:3475
myArray_ContiguousFromObject
#define myArray_ContiguousFromObject
Definition: plplotcPYTHON_wrap.c:3175
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:22217
SWIG_strnlen
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
Definition: plplotcPYTHON_wrap.c:3118
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:6955
do_f2eval_callback
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
Definition: plplotcPYTHON_wrap.c:3582
plwidth
#define plwidth
Definition: plplot.h:863
swigobject_methods
static PyMethodDef swigobject_methods[]
Definition: plplotcPYTHON_wrap.c:1614
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:4214
SWIG_Python_newvarlink
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
Definition: plplotcPYTHON_wrap.c:22669
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:2646
_wrap_PLGraphicsIn_state_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3947
plcol0
#define plcol0
Definition: plplot.h:702
SWIG_UnpackDataName
const SWIGRUNTIME char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplotcPYTHON_wrap.c:715
_wrap_plline3
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8319
plgra
#define plgra
Definition: plplot.h:740
_wrap_plot3dcl
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8908
SWIG_newvarlink
#define SWIG_newvarlink()
Definition: plplotcPYTHON_wrap.c:22496
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotcPYTHON_wrap.c:2756
SwigPyClientData::newargs
PyObject * newargs
Definition: plplotcPYTHON_wrap.c:1267
_wrap_plerrx
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5802
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:5287
_wrap_plgcompression
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6415
SwigPyPacked
Definition: plplotcPYTHON_wrap.c:1768
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:9581
SWIG_Python_ArgFail
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
Definition: plplotcPYTHON_wrap.c:2477
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:22513
_swigc__p_PLcGrid
static swig_cast_info _swigc__p_PLcGrid[]
Definition: plplotcPYTHON_wrap.c:22218
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:1376
_wrap_plprec
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9675
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:4623
SwigPyClientData::delargs
int delargs
Definition: plplotcPYTHON_wrap.c:1269
_wrap_plgstrm
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7007
SWIG_ArgError
#define SWIG_ArgError(r)
Definition: plplotcPYTHON_wrap.c:290
CB_1
Definition: plplotcPYTHON_wrap.c:3475
_wrap_plgver
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7029
SWIG_Python_GetSwigThis
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
Definition: plplotcPYTHON_wrap.c:1966
_wrap_plgdiplt
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6532
SWIG_InternalNewPointerObj
#define SWIG_InternalNewPointerObj(ptr, type, flags)
Definition: plplotcPYTHON_wrap.c:1067
_wrap_plwidth
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13418
plgvpw
#define plgvpw
Definition: plplot.h:747
Xlen
static PLINT Xlen
Definition: plplotcPYTHON_wrap.c:2703
_wrap_PLGraphicsIn_dY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4399
_wrap_plgzax
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7218
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:6626
SWIG_Python_ErrorType
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
Definition: plplotcPYTHON_wrap.c:841
SWIG_Python_RaiseOrModifyTypeError
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
Definition: plplotcPYTHON_wrap.c:921
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:2493
SWIGINTERN
#define SWIGINTERN
Definition: plplotcPYTHON_wrap.c:76
_wrap_plsfci
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11259
plsdiplz
#define plsdiplz
Definition: plplot.h:811
swig_varlink_str
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
Definition: plplotcPYTHON_wrap.c:22526
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:1404
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:1177
_wrap_plmaptex
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13813
_wrap_plschr
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9986
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:7102
SWIG_AsVal_char
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
Definition: plplotcPYTHON_wrap.c:3134
SwigPyObject
Definition: plplotcPYTHON_wrap.c:1347
_wrap_plcpstrm
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5615
SwigPyObject_type
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
Definition: plplotcPYTHON_wrap.c:1479
_wrap_plvasp
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13064
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:12696
pltr_type
enum callback_type pltr_type
_wrap_plsori
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11911
_wrap_plszax
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12998
CB_Python
Definition: plplotcPYTHON_wrap.c:3475
_wrap_plsstrm
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12073
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplotcPYTHON_wrap.c:22228
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:22678
_wrap_pllsty
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8386
_wrap_plreplot
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9907
_wrap_PLGraphicsIn_wX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4451
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:5309
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:12153
plpoin3
#define plpoin3
Definition: plplot.h:781
SWIGPY_CAPSULE_NAME
#define SWIGPY_CAPSULE_NAME
Definition: plplotcPYTHON_wrap.c:828
_wrap_plaxes
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4767
SWIGTYPE_p_double
#define SWIGTYPE_p_double
Definition: plplotcPYTHON_wrap.c:2640
_wrap_plspal0
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11994
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:11769
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:6805
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SwigPyPacked_repr
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
Definition: plplotcPYTHON_wrap.c:1776
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplotcPYTHON_wrap.c:22185
SWIG_PyInstanceMethod_New
SWIGINTERN PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
Definition: plplotcPYTHON_wrap.c:22808
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:22226
SWIG_PYTHON_THREAD_END_BLOCK
#define SWIG_PYTHON_THREAD_END_BLOCK
Definition: plplotcPYTHON_wrap.c:1001
pladv
#define pladv
Definition: plplot.h:692
_wrap_plcolorbar
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7937
_wrap_plsxax
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12884
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:4690
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SwigPyClientData::pytype
PyTypeObject * pytype
Definition: plplotcPYTHON_wrap.c:1271
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:4347
_wrap_plscmap1n
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10592
SwigPyClientData
Definition: plplotcPYTHON_wrap.c:1264
plpat
#define plpat
Definition: plplot.h:779
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplotcPYTHON_wrap.c:22232
_wrap_plgriddata
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6817
_wrap_plsvect
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12766
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplotcPYTHON_wrap.c:22227
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:2204
SwigPyObject_repr
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
Definition: plplotcPYTHON_wrap.c:1416
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:2761
plsmema
#define plsmema
Definition: plplot.h:828
swig_varlink_getattr
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
Definition: plplotcPYTHON_wrap.c:22575
SWIG_SyntaxError
#define SWIG_SyntaxError
Definition: plplotcPYTHON_wrap.c:739
SWIG_Python_DestroyModule
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
Definition: plplotcPYTHON_wrap.c:2379
SwigPyObject_repr2
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
Definition: plplotcPYTHON_wrap.c:1437
_wrap_plGetCursor
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14518
_wrap_plClearOpts
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14389
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:10015
_wrap_plcol0
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5265
plot3dc
#define plot3dc
Definition: plplot.h:776
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplotcPYTHON_wrap.c:2760
_wrap_plmapfill
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13935
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
_wrap_plscmap0a
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10083
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:2758
_wrap_pllab
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7435
SWIG_From_double
#define SWIG_From_double
Definition: plplotcPYTHON_wrap.c:2752
plfill
#define plfill
Definition: plplot.h:717
_wrap_plcont
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5410
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:2032
plglevel
#define plglevel
Definition: plplot.h:738
SWIG_Python_TypeError
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:2498
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:1787
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:5936
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:2788
SWIG_Python_SetConstant
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
Definition: plplotcPYTHON_wrap.c:1146
SWIGTYPE_p_unsigned_int
#define SWIGTYPE_p_unsigned_int
Definition: plplotcPYTHON_wrap.c:2649
SWIG_STATIC_POINTER
#define SWIG_STATIC_POINTER(var)
Definition: plplotcPYTHON_wrap.c:1232
plscmap1l
#define plscmap1l
Definition: plplot.h:796
SwigPyClientData::destroy
PyObject * destroy
Definition: plplotcPYTHON_wrap.c:1268
_wrap_PLGraphicsIn_button_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4051
_wrap_plssub
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12095
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:12405
plgstrm
#define plgstrm
Definition: plplot.h:744
plend
#define plend
Definition: plplot.h:709
SWIG_MangledTypeQuery
#define SWIG_MangledTypeQuery(name)
Definition: plplotcPYTHON_wrap.c:2653
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2497
PLGraphicsIn_swiginit
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4568
swig_const_info
struct swig_const_info swig_const_info