PLplot  5.11.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplot_octaveOCTAVE_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGOCTAVE
12 #define SWIG_name_d "plplot_octave"
13 #define SWIG_name plplot_octave
14 
15 #define SWIG_global_name "cvar"
16 #define SWIG_op_prefix "op_"
17 
18 
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22  struct SwigMovePointer {
23  T *ptr;
24  SwigMovePointer(T *p) : ptr(p) { }
25  ~SwigMovePointer() { delete ptr; }
26  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27  } pointer;
28  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31  SwigValueWrapper() : pointer(0) { }
32  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33  operator T&() const { return *pointer.ptr; }
34  T *operator&() { return pointer.ptr; }
35 };
36 
37 template <typename T> T SwigValueInit() {
38  return T();
39 }
40 #endif
41 
42 /* -----------------------------------------------------------------------------
43  * This section contains generic SWIG labels for method/variable
44  * declarations/attributes, and other compiler dependent labels.
45  * ----------------------------------------------------------------------------- */
46 
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59 
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68 
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83 
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89 
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97 
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102 
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107 
108 /* exporting methods */
109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 # ifndef GCC_HASCLASSVISIBILITY
111 # define GCC_HASCLASSVISIBILITY
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 
151 
152 #include <iostream>
153 #include <octave/oct.h>
154 #include <octave/Cell.h>
155 #include <octave/dynamic-ld.h>
156 #include <octave/oct-env.h>
157 #include <octave/oct-map.h>
158 #include <octave/ov-fcn-handle.h>
159 #include <octave/parse.h>
160 #include <octave/toplev.h>
161 #include <octave/unwind-prot.h>
162 
163 /* -----------------------------------------------------------------------------
164  * swigrun.swg
165  *
166  * This file contains generic C API SWIG runtime support for pointer
167  * type checking.
168  * ----------------------------------------------------------------------------- */
169 
170 /* This should only be incremented when either the layout of swig_type_info changes,
171  or for whatever reason, the runtime changes incompatibly */
172 #define SWIG_RUNTIME_VERSION "4"
173 
174 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
175 #ifdef SWIG_TYPE_TABLE
176 # define SWIG_QUOTE_STRING(x) #x
177 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
178 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
179 #else
180 # define SWIG_TYPE_TABLE_NAME
181 #endif
182 
183 /*
184  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
185  creating a static or dynamic library from the SWIG runtime code.
186  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
187 
188  But only do this if strictly necessary, ie, if you have problems
189  with your compiler or suchlike.
190 */
191 
192 #ifndef SWIGRUNTIME
193 # define SWIGRUNTIME SWIGINTERN
194 #endif
195 
196 #ifndef SWIGRUNTIMEINLINE
197 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
198 #endif
199 
200 /* Generic buffer size */
201 #ifndef SWIG_BUFFER_SIZE
202 # define SWIG_BUFFER_SIZE 1024
203 #endif
204 
205 /* Flags for pointer conversions */
206 #define SWIG_POINTER_DISOWN 0x1
207 #define SWIG_CAST_NEW_MEMORY 0x2
208 
209 /* Flags for new pointer objects */
210 #define SWIG_POINTER_OWN 0x1
211 
212 
213 /*
214  Flags/methods for returning states.
215 
216  The SWIG conversion methods, as ConvertPtr, return an integer
217  that tells if the conversion was successful or not. And if not,
218  an error code can be returned (see swigerrors.swg for the codes).
219 
220  Use the following macros/flags to set or process the returning
221  states.
222 
223  In old versions of SWIG, code such as the following was usually written:
224 
225  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
226  // success code
227  } else {
228  //fail code
229  }
230 
231  Now you can be more explicit:
232 
233  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
234  if (SWIG_IsOK(res)) {
235  // success code
236  } else {
237  // fail code
238  }
239 
240  which is the same really, but now you can also do
241 
242  Type *ptr;
243  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
244  if (SWIG_IsOK(res)) {
245  // success code
246  if (SWIG_IsNewObj(res) {
247  ...
248  delete *ptr;
249  } else {
250  ...
251  }
252  } else {
253  // fail code
254  }
255 
256  I.e., now SWIG_ConvertPtr can return new objects and you can
257  identify the case and take care of the deallocation. Of course that
258  also requires SWIG_ConvertPtr to return new result values, such as
259 
260  int SWIG_ConvertPtr(obj, ptr,...) {
261  if (<obj is ok>) {
262  if (<need new object>) {
263  *ptr = <ptr to new allocated object>;
264  return SWIG_NEWOBJ;
265  } else {
266  *ptr = <ptr to old object>;
267  return SWIG_OLDOBJ;
268  }
269  } else {
270  return SWIG_BADOBJ;
271  }
272  }
273 
274  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
275  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
276  SWIG errors code.
277 
278  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
279  allows to return the 'cast rank', for example, if you have this
280 
281  int food(double)
282  int fooi(int);
283 
284  and you call
285 
286  food(1) // cast rank '1' (1 -> 1.0)
287  fooi(1) // cast rank '0'
288 
289  just use the SWIG_AddCast()/SWIG_CheckState()
290 */
291 
292 #define SWIG_OK (0)
293 #define SWIG_ERROR (-1)
294 #define SWIG_IsOK(r) (r >= 0)
295 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
296 
297 /* The CastRankLimit says how many bits are used for the cast rank */
298 #define SWIG_CASTRANKLIMIT (1 << 8)
299 /* The NewMask denotes the object was created (using new/malloc) */
300 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
301 /* The TmpMask is for in/out typemaps that use temporal objects */
302 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
303 /* Simple returning values */
304 #define SWIG_BADOBJ (SWIG_ERROR)
305 #define SWIG_OLDOBJ (SWIG_OK)
306 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
307 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
308 /* Check, add and del mask methods */
309 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
310 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
311 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
312 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
313 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
314 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
315 
316 /* Cast-Rank Mode */
317 #if defined(SWIG_CASTRANK_MODE)
318 # ifndef SWIG_TypeRank
319 # define SWIG_TypeRank unsigned long
320 # endif
321 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
322 # define SWIG_MAXCASTRANK (2)
323 # endif
324 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
325 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
326 SWIGINTERNINLINE int SWIG_AddCast(int r) {
327  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
328 }
329 SWIGINTERNINLINE int SWIG_CheckState(int r) {
330  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
331 }
332 #else /* no cast-rank mode */
333 # define SWIG_AddCast
334 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
335 #endif
336 
337 
338 #include <string.h>
339 
340 #ifdef __cplusplus
341 extern "C" {
342 #endif
343 
344 typedef void *(*swig_converter_func)(void *, int *);
345 typedef struct swig_type_info *(*swig_dycast_func)(void **);
346 
347 /* Structure to store information on one type */
348 typedef struct swig_type_info {
349  const char *name; /* mangled name of this type */
350  const char *str; /* human readable name of this type */
351  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
352  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
353  void *clientdata; /* language specific type data */
354  int owndata; /* flag if the structure owns the clientdata */
356 
357 /* Structure to store a type and conversion function used for casting */
358 typedef struct swig_cast_info {
359  swig_type_info *type; /* pointer to type that is equivalent to this type */
360  swig_converter_func converter; /* function to cast the void pointers */
361  struct swig_cast_info *next; /* pointer to next cast in linked list */
362  struct swig_cast_info *prev; /* pointer to the previous cast */
364 
365 /* Structure used to store module information
366  * Each module generates one structure like this, and the runtime collects
367  * all of these structures and stores them in a circularly linked list.*/
368 typedef struct swig_module_info {
369  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
370  size_t size; /* Number of types in this module */
371  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
372  swig_type_info **type_initial; /* Array of initially generated type structures */
373  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
374  void *clientdata; /* Language specific module data */
376 
377 /*
378  Compare two type names skipping the space characters, therefore
379  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
380 
381  Return 0 when the two name types are equivalent, as in
382  strncmp, but skipping ' '.
383 */
384 SWIGRUNTIME int
385 SWIG_TypeNameComp(const char *f1, const char *l1,
386  const char *f2, const char *l2) {
387  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
388  while ((*f1 == ' ') && (f1 != l1)) ++f1;
389  while ((*f2 == ' ') && (f2 != l2)) ++f2;
390  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
391  }
392  return (int)((l1 - f1) - (l2 - f2));
393 }
394 
395 /*
396  Check type equivalence in a name list like <name1>|<name2>|...
397  Return 0 if not equal, 1 if equal
398 */
399 SWIGRUNTIME int
400 SWIG_TypeEquiv(const char *nb, const char *tb) {
401  int equiv = 0;
402  const char* te = tb + strlen(tb);
403  const char* ne = nb;
404  while (!equiv && *ne) {
405  for (nb = ne; *ne; ++ne) {
406  if (*ne == '|') break;
407  }
408  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
409  if (*ne) ++ne;
410  }
411  return equiv;
412 }
413 
414 /*
415  Check type equivalence in a name list like <name1>|<name2>|...
416  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
417 */
418 SWIGRUNTIME int
419 SWIG_TypeCompare(const char *nb, const char *tb) {
420  int equiv = 0;
421  const char* te = tb + strlen(tb);
422  const char* ne = nb;
423  while (!equiv && *ne) {
424  for (nb = ne; *ne; ++ne) {
425  if (*ne == '|') break;
426  }
427  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
428  if (*ne) ++ne;
429  }
430  return equiv;
431 }
432 
433 
434 /*
435  Check the typename
436 */
438 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
439  if (ty) {
440  swig_cast_info *iter = ty->cast;
441  while (iter) {
442  if (strcmp(iter->type->name, c) == 0) {
443  if (iter == ty->cast)
444  return iter;
445  /* Move iter to the top of the linked list */
446  iter->prev->next = iter->next;
447  if (iter->next)
448  iter->next->prev = iter->prev;
449  iter->next = ty->cast;
450  iter->prev = 0;
451  if (ty->cast) ty->cast->prev = iter;
452  ty->cast = iter;
453  return iter;
454  }
455  iter = iter->next;
456  }
457  }
458  return 0;
459 }
460 
461 /*
462  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
463 */
466  if (ty) {
467  swig_cast_info *iter = ty->cast;
468  while (iter) {
469  if (iter->type == from) {
470  if (iter == ty->cast)
471  return iter;
472  /* Move iter to the top of the linked list */
473  iter->prev->next = iter->next;
474  if (iter->next)
475  iter->next->prev = iter->prev;
476  iter->next = ty->cast;
477  iter->prev = 0;
478  if (ty->cast) ty->cast->prev = iter;
479  ty->cast = iter;
480  return iter;
481  }
482  iter = iter->next;
483  }
484  }
485  return 0;
486 }
487 
488 /*
489  Cast a pointer up an inheritance hierarchy
490 */
491 SWIGRUNTIMEINLINE void *
492 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
493  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
494 }
495 
496 /*
497  Dynamic pointer casting. Down an inheritance hierarchy
498 */
501  swig_type_info *lastty = ty;
502  if (!ty || !ty->dcast) return ty;
503  while (ty && (ty->dcast)) {
504  ty = (*ty->dcast)(ptr);
505  if (ty) lastty = ty;
506  }
507  return lastty;
508 }
509 
510 /*
511  Return the name associated with this type
512 */
513 SWIGRUNTIMEINLINE const char *
515  return ty->name;
516 }
517 
518 /*
519  Return the pretty name associated with this type,
520  that is an unmangled type name in a form presentable to the user.
521 */
522 SWIGRUNTIME const char *
524  /* The "str" field contains the equivalent pretty names of the
525  type, separated by vertical-bar characters. We choose
526  to print the last name, as it is often (?) the most
527  specific. */
528  if (!type) return NULL;
529  if (type->str != NULL) {
530  const char *last_name = type->str;
531  const char *s;
532  for (s = type->str; *s; s++)
533  if (*s == '|') last_name = s+1;
534  return last_name;
535  }
536  else
537  return type->name;
538 }
539 
540 /*
541  Set the clientdata field for a type
542 */
543 SWIGRUNTIME void
545  swig_cast_info *cast = ti->cast;
546  /* if (ti->clientdata == clientdata) return; */
547  ti->clientdata = clientdata;
548 
549  while (cast) {
550  if (!cast->converter) {
551  swig_type_info *tc = cast->type;
552  if (!tc->clientdata) {
553  SWIG_TypeClientData(tc, clientdata);
554  }
555  }
556  cast = cast->next;
557  }
558 }
559 SWIGRUNTIME void
561  SWIG_TypeClientData(ti, clientdata);
562  ti->owndata = 1;
563 }
564 
565 /*
566  Search for a swig_type_info structure only by mangled name
567  Search is a O(log #types)
568 
569  We start searching at module start, and finish searching when start == end.
570  Note: if start == end at the beginning of the function, we go all the way around
571  the circular list.
572 */
575  swig_module_info *end,
576  const char *name) {
577  swig_module_info *iter = start;
578  do {
579  if (iter->size) {
580  register size_t l = 0;
581  register size_t r = iter->size - 1;
582  do {
583  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
584  register size_t i = (l + r) >> 1;
585  const char *iname = iter->types[i]->name;
586  if (iname) {
587  register int compare = strcmp(name, iname);
588  if (compare == 0) {
589  return iter->types[i];
590  } else if (compare < 0) {
591  if (i) {
592  r = i - 1;
593  } else {
594  break;
595  }
596  } else if (compare > 0) {
597  l = i + 1;
598  }
599  } else {
600  break; /* should never happen */
601  }
602  } while (l <= r);
603  }
604  iter = iter->next;
605  } while (iter != end);
606  return 0;
607 }
608 
609 /*
610  Search for a swig_type_info structure for either a mangled name or a human readable name.
611  It first searches the mangled names of the types, which is a O(log #types)
612  If a type is not found it then searches the human readable names, which is O(#types).
613 
614  We start searching at module start, and finish searching when start == end.
615  Note: if start == end at the beginning of the function, we go all the way around
616  the circular list.
617 */
620  swig_module_info *end,
621  const char *name) {
622  /* STEP 1: Search the name field using binary search */
623  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
624  if (ret) {
625  return ret;
626  } else {
627  /* STEP 2: If the type hasn't been found, do a complete search
628  of the str field (the human readable name) */
629  swig_module_info *iter = start;
630  do {
631  register size_t i = 0;
632  for (; i < iter->size; ++i) {
633  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
634  return iter->types[i];
635  }
636  iter = iter->next;
637  } while (iter != end);
638  }
639 
640  /* neither found a match */
641  return 0;
642 }
643 
644 /*
645  Pack binary data into a string
646 */
647 SWIGRUNTIME char *
648 SWIG_PackData(char *c, void *ptr, size_t sz) {
649  static const char hex[17] = "0123456789abcdef";
650  register const unsigned char *u = (unsigned char *) ptr;
651  register const unsigned char *eu = u + sz;
652  for (; u != eu; ++u) {
653  register unsigned char uu = *u;
654  *(c++) = hex[(uu & 0xf0) >> 4];
655  *(c++) = hex[uu & 0xf];
656  }
657  return c;
658 }
659 
660 /*
661  Unpack binary data from a string
662 */
663 SWIGRUNTIME const char *
664 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
665  register unsigned char *u = (unsigned char *) ptr;
666  register const unsigned char *eu = u + sz;
667  for (; u != eu; ++u) {
668  register char d = *(c++);
669  register unsigned char uu;
670  if ((d >= '0') && (d <= '9'))
671  uu = ((d - '0') << 4);
672  else if ((d >= 'a') && (d <= 'f'))
673  uu = ((d - ('a'-10)) << 4);
674  else
675  return (char *) 0;
676  d = *(c++);
677  if ((d >= '0') && (d <= '9'))
678  uu |= (d - '0');
679  else if ((d >= 'a') && (d <= 'f'))
680  uu |= (d - ('a'-10));
681  else
682  return (char *) 0;
683  *u = uu;
684  }
685  return c;
686 }
687 
688 /*
689  Pack 'void *' into a string buffer.
690 */
691 SWIGRUNTIME char *
692 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
693  char *r = buff;
694  if ((2*sizeof(void *) + 2) > bsz) return 0;
695  *(r++) = '_';
696  r = SWIG_PackData(r,&ptr,sizeof(void *));
697  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
698  strcpy(r,name);
699  return buff;
700 }
701 
702 SWIGRUNTIME const char *
703 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
704  if (*c != '_') {
705  if (strcmp(c,"NULL") == 0) {
706  *ptr = (void *) 0;
707  return name;
708  } else {
709  return 0;
710  }
711  }
712  return SWIG_UnpackData(++c,ptr,sizeof(void *));
713 }
714 
715 SWIGRUNTIME char *
716 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
717  char *r = buff;
718  size_t lname = (name ? strlen(name) : 0);
719  if ((2*sz + 2 + lname) > bsz) return 0;
720  *(r++) = '_';
721  r = SWIG_PackData(r,ptr,sz);
722  if (lname) {
723  strncpy(r,name,lname+1);
724  } else {
725  *r = 0;
726  }
727  return buff;
728 }
729 
730 SWIGRUNTIME const char *
731 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
732  if (*c != '_') {
733  if (strcmp(c,"NULL") == 0) {
734  memset(ptr,0,sz);
735  return name;
736  } else {
737  return 0;
738  }
739  }
740  return SWIG_UnpackData(++c,ptr,sz);
741 }
742 
743 #ifdef __cplusplus
744 }
745 #endif
746 
747 /* Errors in SWIG */
748 #define SWIG_UnknownError -1
749 #define SWIG_IOError -2
750 #define SWIG_RuntimeError -3
751 #define SWIG_IndexError -4
752 #define SWIG_TypeError -5
753 #define SWIG_DivisionByZero -6
754 #define SWIG_OverflowError -7
755 #define SWIG_SyntaxError -8
756 #define SWIG_ValueError -9
757 #define SWIG_SystemError -10
758 #define SWIG_AttributeError -11
759 #define SWIG_MemoryError -12
760 #define SWIG_NullReferenceError -13
761 
762 
763 
764 
765 #include <octave/version.h>
766 #ifndef OCTAVE_API_VERSION_NUMBER
767 
768  // Hack to distinguish between Octave 3.2 and earlier versions before OCTAVE_API_VERSION_NUMBER existed
769  #define ComplexLU __ignore
770  #include <octave/CmplxLU.h>
771  #undef ComplexLU
772  #ifdef octave_Complex_LU_h
773  # define OCTAVE_API_VERSION_NUMBER 36
774  #else
775  # define OCTAVE_API_VERSION_NUMBER 37
776  #endif
777 
778 #endif
779 
780 #if OCTAVE_API_VERSION_NUMBER < 37
781 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
782 #else
783 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
784 #endif
785 
786 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
787  if (num_args > max_args && !varargs)
788  error("function %s takes at most %i arguments", func_name, max_args);
789  else if (num_args < min_args)
790  error("function %s requires at least %i arguments", func_name, min_args);
791  else
792  return true;
793  return false;
794 }
795 
796 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
797  ovl->append(ov);
798  return ovl;
799 }
800 
801 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
802  switch (code) {
803  case SWIG_MemoryError:
804  return "SWIG_MemoryError";
805  case SWIG_IOError:
806  return "SWIG_IOError";
807  case SWIG_RuntimeError:
808  return "SWIG_RuntimeError";
809  case SWIG_IndexError:
810  return "SWIG_IndexError";
811  case SWIG_TypeError:
812  return "SWIG_TypeError";
813  case SWIG_DivisionByZero:
814  return "SWIG_DivisionByZero";
815  case SWIG_OverflowError:
816  return "SWIG_OverflowError";
817  case SWIG_SyntaxError:
818  return "SWIG_SyntaxError";
819  case SWIG_ValueError:
820  return "SWIG_ValueError";
821  case SWIG_SystemError:
822  return "SWIG_SystemError";
823  case SWIG_AttributeError:
824  return "SWIG_AttributeError";
825  }
826  return "SWIG unknown error";
827 }
828 
829 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
830  octave_value type(SWIG_ErrorType(code));
831  std::string r = msg;
832  r += " (" + type.string_value() + ")";
833  error(r.c_str());
834  return octave_value(r);
835 }
836 
837 #define SWIG_fail goto fail
838 
839 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
840 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
841 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
842 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
843 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
844 #define swig_owntype int
845 
846 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
847 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
848 
849 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
850 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
851 
852 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
853 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
854 
855 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
856 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
857 #define SWIG_MODULE_CLIENTDATA_TYPE void*
858 
859 #define Octave_Error_Occurred() 0
860 #define SWIG_Octave_AddErrorMsg(msg) {;}
861 
864 
865 // For backward compatibility only
866 #define SWIG_POINTER_EXCEPTION 0
867 #define SWIG_arg_fail(arg) 0
868 
869 // Runtime API implementation
870 
871 #include <map>
872 #include <vector>
873 #include <string>
874 
875 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
876 class octave_swig_type;
877 
878 namespace Swig {
879 
880 #ifdef SWIG_DIRECTORS
881 
882  class Director;
883 
884  typedef std::map < void *, Director * > rtdir_map;
885  SWIGINTERN rtdir_map* get_rtdir_map();
886  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
887  SWIGINTERNINLINE void erase_rtdir(void *vptr);
888  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
889 
890  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
891  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
892  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
893 
894 #endif
895 
896  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
898  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
899 }
900 
901 #ifdef SWIG_DIRECTORS
902 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
903 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
904 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
905 #endif
906 
908  const char *name;
912  int flags; // 1 static, 2 global
913  const char *doc;
914  bool is_static() const {
915  return flags &1;
916  } bool is_global() const {
917  return flags &2;
918  }
919  };
920 
922  const char *name;
924  int director;
926  const char *constructor_doc;
929  const char **base_names;
931  };
932 
933  // octave_swig_type plays the role of both the shadow class and the class
934  // representation within Octave, since there is no support for classes.
935  //
936  // These should really be decoupled, with the class support added to Octave
937  // and the shadow class given by an m-file script. That would dramatically
938  // reduce the runtime complexity, and be more in line w/ other modules.
939 
940  class octave_swig_type:public octave_base_value {
941  struct cpp_ptr {
942  void *ptr;
943  bool destroyed;
944  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
945  }};
946  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
947 
949 
950  const swig_type_info *construct_type; // type of special type object
951  std::vector < type_ptr_pair > types; // our c++ base classes
952  int own; // whether we call c++ destructors when we die
953 
954  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
955  typedef std::map < std::string, member_value_pair > member_map;
958 
959  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
960  if (!type->clientdata)
961  return 0;
963  const swig_octave_member *m;
964  for (m = c->members; m->name; ++m)
965  if (m->name == name)
966  return m;
967  for (int j = 0; c->base_names[j]; ++j) {
968  if (!c->base[j]) {
969  if (!module)
970  module = SWIG_GetModule(0);
971  assert(module);
973  }
974  if (!c->base[j])
975  return 0;
976  if ((m = find_member(c->base[j], name)))
977  return m;
978  }
979  return 0;
980  }
981 
982  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
983  member_map::iterator it = members.find(name);
984  if (it != members.end())
985  return &it->second;
986  const swig_octave_member *m;
987  for (unsigned int j = 0; j < types.size(); ++j)
988  if ((m = find_member(types[j].first, name)))
989  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
990  if (!insert_if_not_found)
991  return 0;
992  return &members[name];
993  }
994 
995  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
996  if (!base) {
997  for (unsigned int j = 0; j < types.size(); ++j) {
998  assert(types[j].first->clientdata);
999  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1000  if (cj->name == name)
1001  return types[j].first;
1002  }
1003  return 0;
1004  }
1005  assert(base->clientdata);
1007  for (int j = 0; c->base_names[j]; ++j) {
1008  if (!c->base[j]) {
1009  if (!module)
1010  module = SWIG_GetModule(0);
1011  assert(module);
1013  }
1014  if (!c->base[j])
1015  return 0;
1016  assert(c->base[j]->clientdata);
1018  if (cj->name == name)
1019  return c->base[j];
1020  }
1021  return 0;
1022  }
1023 
1024  void load_members(const swig_octave_class* c,member_map& out) const {
1025  for (const swig_octave_member *m = c->members; m->name; ++m) {
1026  if (out.find(m->name) == out.end())
1027  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1028  }
1029  for (int j = 0; c->base_names[j]; ++j) {
1030  if (!c->base[j]) {
1031  if (!module)
1032  module = SWIG_GetModule(0);
1033  assert(module);
1035  }
1036  if (!c->base[j])
1037  continue;
1038  assert(c->base[j]->clientdata);
1039  const swig_octave_class *cj =
1040  (const swig_octave_class *) c->base[j]->clientdata;
1041  load_members(cj,out);
1042  }
1043  }
1044 
1045  void load_members(member_map& out) const {
1046  out=members;
1047  for (unsigned int j = 0; j < types.size(); ++j)
1048  if (types[j].first->clientdata)
1049  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1050  }
1051 
1052  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1053  if (m->second.is_defined())
1054  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1055  else if (m->first && m->first->method)
1056  return m->first->method(args, nargout);
1057  error("member not defined or not invocable");
1058  return octave_value_list();
1059  }
1060 
1061  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
1062  member_value_pair *m = find_member(symbol, false);
1063  if (!m || m->first->is_static() || m->first->is_global())
1064  return false;
1065  octave_value_list args;
1066  args.append(as_value());
1067  octave_value_list argout(member_invoke(m, args, 1));
1068  if (argout.length() < 1)
1069  return false;
1070  ret = argout(0);
1071  return true;
1072  }
1073 
1074  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
1075  member_value_pair *m = find_member(symbol, false);
1076  if (!m || m->first->is_static() || m->first->is_global())
1077  return false;
1078  octave_value_list args;
1079  args.append(as_value());
1080  args.append(make_value_hack(rhs));
1081  octave_value_list argout(member_invoke(m, args, 1));
1082  if (argout.length() < 1)
1083  return false;
1084  ret = argout(0);
1085  return true;
1086  }
1087 
1088  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
1089  member_value_pair *m = find_member(symbol, false);
1090  if (!m || m->first->is_static() || m->first->is_global())
1091  return false;
1092  octave_value_list args;
1093  args.append(as_value());
1094  args.append(rhs);
1095  octave_value_list argout(member_invoke(m, args, 1));
1096  if (argout.length() >= 1)
1097  ret = argout(0);
1098  return true;
1099  }
1100 
1101  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1102  if (m->second.is_defined())
1103  return m->second;
1104  else if (m->first) {
1105  if (m->first->get_method)
1106  return m->first->get_method(args, 1);
1107  else if (m->first->method)
1108  return octave_value(new octave_builtin(m->first->method));
1109  }
1110  error("undefined member");
1111  return octave_value_list();
1112  }
1113 
1114  static octave_value make_value_hack(const octave_base_value &x) {
1115  ((octave_swig_type &) x).count++;
1116  return octave_value((octave_base_value *) &x);
1117  }
1118 
1121  public:
1122 
1123  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1124  bool _always_static = false)
1125  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1126  always_static(_always_static) {
1127  if (_type || _ptr)
1128  types.push_back(std::make_pair(_type, _ptr));
1129 #ifdef SWIG_DIRECTORS
1130  if (_ptr) {
1131  Swig::Director *d = Swig::get_rtdir(_ptr);
1132  if (d)
1133  Swig::swig_director_set_self(d, this);
1134  }
1135 #endif
1136  }
1137 
1139  if (own) {
1140  ++count;
1141  for (unsigned int j = 0; j < types.size(); ++j) {
1142  if (!types[j].first || !types[j].first->clientdata)
1143  continue;
1144  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1145  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1146  c->destructor(as_value(), 0);
1147  }
1148  }
1149  }
1150 #ifdef SWIG_DIRECTORS
1151  for (unsigned int j = 0; j < types.size(); ++j)
1152  Swig::erase_rtdir(types[j].second.ptr);
1153 #endif
1154  }
1155 
1156  dim_vector dims(void) const {
1157  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1158 
1159  // Find the __dims__ method of this object
1160  member_value_pair *m = nc_this->find_member("__dims__", false);
1161 
1162  if (!m) return dim_vector(1,1);
1163 
1164  // Call the __dims__ method of this object
1165  octave_value_list inarg;
1166  inarg.append(nc_this->as_value());
1167  octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
1168 
1169  // __dims__ should return (at least) one output argument
1170  if (outarg.length() < 1) return dim_vector(1,1);
1171 
1172  octave_value & out = outarg(0);
1173 
1174  // Return value should be cell or matrix of integers
1175  if (out.is_cell()) {
1176  const Cell & c=out.cell_value();
1177  int ndim = c.rows();
1178  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1179 
1180  dim_vector d;
1181  d.resize(ndim < 2 ? 2 : ndim);
1182  d(0) = d(1) = 1;
1183 
1184  // Fill in dim_vector
1185  for (int k=0;k<ndim;k++) {
1186  const octave_value& obj = c(k);
1187  d.elem(k) = obj.int_value();
1188 
1189  // __dims__ should return a cell filled with integers
1190  if (error_state) return dim_vector(1,1);
1191  }
1192  return d;
1193  } else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1194  if (out.rows()==1 || out.columns()==1) {
1195  Array<int> a = out.int_vector_value();
1196  if (error_state) return dim_vector(1,1);
1197  dim_vector d;
1198  d.resize(a.numel() < 2 ? 2 : a.numel());
1199  d(0) = d(1) = 1;
1200  for (int k=0;k<a.numel();k++) {
1201  d.elem(k) = a(k);
1202  }
1203  return d;
1204  } else {
1205  return dim_vector(1,1);
1206  }
1207  } else {
1208  return dim_vector(1,1);
1209  }
1210  }
1211 
1212  octave_value as_value() {
1213  ++count;
1214  return Swig::swig_value_ref(this);
1215  }
1216 
1217  void incref() {
1218  ++count;
1219  }
1220 
1221  void decref() {
1222  if (!--count)
1223  delete this;
1224  }
1225 
1226  long swig_this() const {
1227  if (!types.size())
1228  return (long) this;
1229  return (long) types[0].second.ptr;
1230  }
1231  const char* help_text() const {
1232  if (!types.size())
1233  return 0;
1234  if (!types[0].first->clientdata)
1235  return 0;
1236  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1237  return c->constructor_doc;
1238  }
1239 
1240  std::string swig_type_name() const {
1241  // * need some way to manually name subclasses.
1242  // * eg optional first arg to subclass(), or named_subclass()
1243  std::string ret;
1244  for (unsigned int j = 0; j < types.size(); ++j) {
1245  if (j)
1246  ret += "_";
1247  if (types[j].first->clientdata) {
1248  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1249  ret += c->name;
1250  } else
1251  ret += types[j].first->name;
1252  }
1253  return ret;
1254  }
1255 
1257  rhs.own = 0;
1258  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1259  assert(!rhs.types[j].second.destroyed);
1260 #ifdef SWIG_DIRECTORS
1261  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1262  if (d)
1263  Swig::swig_director_set_self(d, this);
1264 #endif
1265  }
1266  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1267  members.insert(rhs.members.begin(), rhs.members.end());
1268  rhs.types.clear();
1269  rhs.members.clear();
1270  }
1271 
1272  typedef member_map::const_iterator swig_member_const_iterator;
1275 
1276  void *cast(swig_type_info *type, int *_own, int flags) {
1277  if (_own)
1278  *_own = own;
1279  if (flags &SWIG_POINTER_DISOWN)
1280  own = 0;
1281  if (!type && types.size())
1282  return types[0].second.ptr;
1283  for (unsigned int j = 0; j < types.size(); ++j)
1284  if (type == types[j].first)
1285  return types[j].second.ptr;
1286  for (unsigned int j = 0; j < types.size(); ++j) {
1287  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1288  if (!tc)
1289  continue;
1290  int newmemory = 0;
1291  void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1292  assert(!newmemory); // newmemory handling not yet implemented
1293  return vptr;
1294  }
1295  return 0;
1296  }
1297 
1298  bool is_owned() const {
1299  return own;
1300  }
1301 
1302 #ifdef SWIG_DIRECTORS
1303  void director_destroyed(Swig::Director *d) {
1304  bool found = false;
1305  for (unsigned int j = 0; j < types.size(); ++j) {
1306  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1307  if (dj == d) {
1308  types[j].second.destroyed = true;
1309  found = true;
1310  }
1311  }
1312  assert(found);
1313  }
1314 #endif
1315 
1316  void assign(const std::string &name, const octave_value &ov) {
1317  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1318  }
1319 
1320  void assign(const std::string &name, const swig_octave_member *m) {
1321  members[name] = std::make_pair(m, octave_value());
1322  }
1323 
1324  octave_base_value *clone() const {
1325  // pass-by-value is probably not desired, and is harder;
1326  // requires calling copy constructors of contained types etc.
1327  assert(0);
1328  *(int *) 0 = 0;
1329  return 0;
1330  }
1331 
1332  octave_base_value *empty_clone() const {
1333  return new octave_swig_type();
1334  }
1335 
1336  bool is_defined() const {
1337  return true;
1338  }
1339 
1340  virtual bool is_map() const {
1341  return true;
1342  }
1343 
1344  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1345  octave_value_list ovl = subsref(ops, idx, 1);
1346  return ovl.length()? ovl(0) : octave_value();
1347  }
1348 
1349  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1350  assert(ops.size() > 0);
1351  assert(ops.size() == idx.size());
1352 
1353  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1354  int skip = 0;
1355  octave_value_list sub_ovl;
1356 
1357  // constructor invocation
1358  if (ops[skip] == '(' && construct_type) {
1359  assert(construct_type->clientdata);
1361  if (!c->constructor) {
1362  error("cannot create instance");
1363  return octave_value_list();
1364  }
1365  octave_value_list args;
1366  if (c->director)
1367  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1368  args.append(*idx_it++);
1369  ++skip;
1370  sub_ovl = c->constructor(args, nargout);
1371  }
1372  // member dereference or invocation
1373  else if (ops[skip] == '.') {
1374  std::string subname;
1375  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1376  for (;;) {
1377  octave_value_list subname_ovl(*idx_it++);
1378  ++skip;
1379  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1380  subname = subname_ovl(0).string_value();
1381 
1382  const swig_type_info *next_base = find_base(subname, base);
1383  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1384  break;
1385  base = next_base;
1386  }
1387 
1388  member_value_pair tmp, *m = &tmp;
1389  if (!base || !(m->first = find_member(base, subname)))
1390  m = find_member(subname, false);
1391  if (!m) {
1392  error("member not found");
1393  return octave_value_list();
1394  }
1395 
1396  octave_value_list args;
1397  if (!always_static &&
1398  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1399  args.append(as_value());
1400  if (skip < (int) ops.size() && ops[skip] == '(' &&
1401  ((m->first && m->first->method) || m->second.is_function() ||
1402  m->second.is_function_handle())) {
1403  args.append(*idx_it++);
1404  ++skip;
1405  sub_ovl = member_invoke(m, args, nargout);
1406  } else {
1407  sub_ovl = member_deref(m, args);
1408  }
1409  }
1410  // index operator
1411  else {
1412  if (ops[skip] == '(' || ops[skip] == '{') {
1413  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1414  octave_value_list args;
1415  args.append(*idx_it++);
1416  ++skip;
1417  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1418  error("error evaluating index operator");
1419  return octave_value_list();
1420  }
1421  } else {
1422  error("unsupported subsref");
1423  return octave_value_list();
1424  }
1425  }
1426 
1427  if (skip >= (int) ops.size())
1428  return sub_ovl;
1429  if (sub_ovl.length() < 1) {
1430  error("bad subs ref");
1431  return octave_value_list();
1432  }
1433  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1434  }
1435 
1436  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1437  assert(ops.size() > 0);
1438  assert(ops.size() == idx.size());
1439 
1440  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1441  int skip = 0;
1442 
1443  if (ops.size() > 1) {
1444  std::list < octave_value_list >::const_iterator last = idx.end();
1445  --last;
1446  std::list < octave_value_list > next_idx(idx.begin(), last);
1447  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1448  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1449  }
1450 
1451  else if (ops[skip] == '(' || ops[skip] == '{') {
1452  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1453  member_value_pair *m = find_member(op_name, false);
1454  if (m) {
1455  octave_value_list args;
1456  args.append(as_value());
1457  args.append(*idx_it);
1458  args.append(rhs);
1459  member_invoke(m, args, 1);
1460  } else
1461  error("%s member not found", op_name);
1462  }
1463 
1464  else if (ops[skip] == '.') {
1465  octave_value_list subname_ovl(*idx_it++);
1466  ++skip;
1467  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1468  std::string subname = subname_ovl(0).string_value();
1469 
1470  member_value_pair *m = find_member(subname, true);
1471  if (!m->first || !m->first->set_method) {
1472  m->first = 0;
1473  m->second = rhs;
1474  } else if (m->first->set_method) {
1475  octave_value_list args;
1476  if (!m->first->is_static() && !m->first->is_global())
1477  args.append(as_value());
1478  args.append(rhs);
1479  m->first->set_method(args, 1);
1480  } else
1481  error("member not assignable");
1482  } else
1483  error("unsupported subsasgn");
1484 
1485  return as_value();
1486  }
1487 
1488  virtual bool is_object() const {
1489  return true;
1490  }
1491 
1492  virtual bool is_string() const {
1493  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1494  return !!nc_this->find_member("__str__", false);
1495  }
1496 
1497  virtual std::string string_value(bool force = false) const {
1498  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1499  member_value_pair *m = nc_this->find_member("__str__", false);
1500  if (!m) {
1501  error("__str__ method not defined");
1502  return std::string();
1503  }
1504  octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
1505  if (outarg.length() < 1 || !outarg(0).is_string()) {
1506  error("__str__ method did not return a string");
1507  return std::string();
1508  }
1509  return outarg(0).string_value();
1510  }
1511 
1512 #if OCTAVE_API_VERSION_NUMBER >= 40
1513  virtual octave_map map_value() const {
1514  return octave_map();
1515  }
1516 #else
1517  virtual Octave_map map_value() const {
1518  return Octave_map();
1519  }
1520 #endif
1521 
1522  virtual string_vector map_keys() const {
1523  member_map tmp;
1524  load_members(tmp);
1525 
1526  string_vector keys(tmp.size());
1527  int k = 0;
1528  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1529  keys(k++) = it->first;
1530 
1531  return keys;
1532  }
1533 
1534  virtual bool save_ascii (std::ostream& os) {
1535  return true;
1536  }
1537 
1538  virtual bool load_ascii (std::istream& is) {
1539  return true;
1540  }
1541 
1542  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1543  return true;
1544  }
1545 
1546  virtual bool load_binary (std::istream& is, bool swap,
1547  oct_mach_info::float_format fmt) {
1548  return true;
1549  }
1550 
1551 #if defined (HAVE_HDF5)
1552  virtual bool
1553  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1554  return true;
1555  }
1556 
1557  virtual bool
1558  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1559  return true;
1560  }
1561 #endif
1562 
1563  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1564  return string_value();
1565  }
1566 
1567  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1568  return string_value();
1569  }
1570 
1571  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1572  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1573  // (rather than any module namespace).
1574 
1575  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1576  if (!fcn)
1577  return false;
1578  ret = fcn->do_multi_index_op(1, args)(0);
1579  return true;
1580  }
1581 
1582  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1584  assert(ost);
1585 
1586  octave_value ret;
1587  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1588  return ret;
1589  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1590  octave_value_list args;
1591  args.append(make_value_hack(x));
1592  if (dispatch_global_op(symbol, args, ret))
1593  return ret;
1594 
1595  error("could not dispatch unary operator");
1596  return octave_value();
1597  }
1598 
1599  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1600  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1601  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1602 
1603  octave_value ret;
1604  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1605  return ret;
1606  if (rhs_ost) {
1607  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1608  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1609  return ret;
1610  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1611  return ret;
1612  }
1613  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1614  return ret;
1615  }
1616 
1617  std::string symbol;
1618  octave_value_list args;
1619  args.append(make_value_hack(lhs));
1620  args.append(make_value_hack(rhs));
1621 
1622  symbol = SWIG_op_prefix;
1623  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1624  symbol += "_";
1625  symbol += op_name;
1626  symbol += "_";
1627  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1628  if (dispatch_global_op(symbol, args, ret))
1629  return ret;
1630 
1631  symbol = SWIG_op_prefix;
1632  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1633  symbol += "_";
1634  symbol += op_name;
1635  symbol += "_";
1636  symbol += "any";
1637  if (dispatch_global_op(symbol, args, ret))
1638  return ret;
1639 
1640  symbol = SWIG_op_prefix;
1641  symbol += "any";
1642  symbol += "_";
1643  symbol += op_name;
1644  symbol += "_";
1645  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1646  if (dispatch_global_op(symbol, args, ret))
1647  return ret;
1648 
1649  error("could not dispatch binary operator");
1650  return octave_value();
1651  }
1652 
1653  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1654  if (is_string()) {
1655  os << string_value();
1656  return;
1657  }
1658 
1659  member_map tmp;
1660  load_members(tmp);
1661 
1662  indent(os);
1663  os << "{"; newline(os);
1664  increment_indent_level();
1665  for (unsigned int j = 0; j < types.size(); ++j) {
1666  indent(os);
1667  if (types[j].first->clientdata) {
1668  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1669  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1670  } else {
1671  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1672  }
1673  }
1674  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1675  indent(os);
1676  if (it->second.first) {
1677  const char *objtype = it->second.first->method ? "method" : "variable";
1678  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1679  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1680  assert(it->second.first->name == it->first);
1681  } else {
1682  os << it->first; newline(os);
1683  }
1684  }
1685  decrement_indent_level();
1686  indent(os);
1687  os << "}"; newline(os);
1688  }
1689  };
1690 
1691  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1692  // will call clone() via make_unique() if there is more than one outstanding
1693  // reference to the lhs, and forces the clone's reference count to 1
1694  // (so you can't just increment your own count and return this).
1695  //
1696  // One way to fix this (without modifying Octave) is to add a level of
1697  // indirection such that clone copies ref-counted pointer and we keep
1698  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1699  //
1700  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1701  // might be nice.
1702 
1703  class octave_swig_ref:public octave_base_value {
1705  public:
1707  :ptr(_ptr) { }
1708 
1710  { if (ptr) ptr->decref(); }
1711 
1713  { return ptr; }
1714 
1715  octave_base_value *clone() const
1716  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1717 
1718  octave_base_value *empty_clone() const
1719  { return new octave_swig_ref(0); }
1720 
1721  dim_vector dims(void) const
1722  { return ptr->dims(); }
1723 
1724  bool is_defined() const
1725  { return ptr->is_defined(); }
1726 
1727  virtual bool is_map() const
1728  { return ptr->is_map(); }
1729 
1730  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1731  { return ptr->subsref(ops, idx); }
1732 
1733  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1734  { return ptr->subsref(ops, idx, nargout); }
1735 
1736  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1737  { return ptr->subsasgn(ops, idx, rhs); }
1738 
1739  virtual bool is_object() const
1740  { return ptr->is_object(); }
1741 
1742  virtual bool is_string() const
1743  { return ptr->is_string(); }
1744 
1745  virtual std::string string_value(bool force = false) const
1746  { return ptr->string_value(force); }
1747 
1748 #if OCTAVE_API_VERSION_NUMBER >= 40
1749  virtual octave_map map_value() const
1750  { return ptr->map_value(); }
1751 #else
1752  virtual Octave_map map_value() const
1753  { return ptr->map_value(); }
1754 #endif
1755 
1756  virtual string_vector map_keys() const
1757  { return ptr->map_keys(); }
1758 
1759  virtual bool save_ascii (std::ostream& os)
1760  { return ptr->save_ascii(os); }
1761 
1762  virtual bool load_ascii (std::istream& is)
1763  { return ptr->load_ascii(is); }
1764 
1765  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
1766  { return ptr->save_binary(os, save_as_floats); }
1767 
1768  virtual bool load_binary (std::istream& is, bool swap,
1769  oct_mach_info::float_format fmt)
1770  { return ptr->load_binary(is, swap, fmt); }
1771 
1772 #if defined (HAVE_HDF5)
1773  virtual bool
1774  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
1775  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
1776 
1777  virtual bool
1778  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
1779  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1780 #endif
1781 
1782  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
1783  { return ptr->convert_to_str(pad, force, type); }
1784 
1785  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
1786  { return ptr->convert_to_str_internal(pad, force, type); }
1787 
1788  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1789  { return ptr->print(os, pr_as_read_syntax); }
1790 
1791  private:
1794  };
1796  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
1797 
1798  class octave_swig_packed:public octave_base_value {
1800  std::vector < char > buf;
1801  public:
1802 
1803  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
1804  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1805  }
1806 
1807  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
1808  if (outtype && outtype != type)
1809  return false;
1810  assert(sz <= buf.size());
1811  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
1812  return true;
1813  }
1814 
1815  octave_base_value *clone() const {
1816  return new octave_swig_packed(*this);
1817  }
1818 
1819  octave_base_value *empty_clone() const {
1820  return new octave_swig_packed();
1821  }
1822 
1823  bool is_defined() const {
1824  return true;
1825  }
1826 
1827  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1828  indent(os);
1829  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
1830  }
1831 
1832 
1833  virtual bool save_ascii (std::ostream& os) {
1834  return true;
1835  }
1836 
1837  virtual bool load_ascii (std::istream& is) {
1838  return true;
1839  }
1840 
1841  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1842  return true;
1843  }
1844 
1845  virtual bool load_binary (std::istream& is, bool swap,
1846  oct_mach_info::float_format fmt) {
1847  return true;
1848  }
1849 
1850 #if defined (HAVE_HDF5)
1851  virtual bool
1852  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1853  return true;
1854  }
1855 
1856  virtual bool
1857  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1858  return true;
1859  }
1860 #endif
1861 
1862  private:
1865  };
1867  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
1868 
1869  static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
1870  error("attempt to set immutable member variable");
1871  return octave_value_list();
1872  }
1873 
1875  const octave_value_list &ovl;
1876  int j;
1877 
1878  octave_value_ref(const octave_value_list &_ovl, int _j)
1879  :ovl(_ovl), j(_j) { }
1880 
1881  operator octave_value() const {
1882  return ovl(j);
1883  }
1884 
1885  octave_value operator*() const {
1886  return ovl(j);
1887  }
1888  };
1889 
1890 
1891 namespace Swig {
1892 
1893  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
1894  return new octave_swig_ref(ost);
1895  }
1896 
1898  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1899  ov = ov.cell_value()(0);
1900  return swig_value_deref(*ov.internal_rep());
1901  }
1902 
1903  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
1904  if (ov.type_id() != octave_swig_ref::static_type_id())
1905  return 0;
1906  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
1907  return osr->get_ptr();
1908  }
1909 
1910 }
1911 
1912 
1913 #define swig_unary_op(name) \
1914 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1915  return octave_swig_type::dispatch_unary_op(x,#name); \
1916 }
1917 #define swig_binary_op(name) \
1918 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1919  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1920 }
1921 #define swigreg_unary_op(name) \
1922 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1923 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1924 #define swigreg_binary_op(name) \
1925 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1926 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1927 
1928  swig_unary_op(not);
1929  swig_unary_op(uplus);
1930  swig_unary_op(uminus);
1931  swig_unary_op(transpose);
1932  swig_unary_op(hermitian);
1933  swig_unary_op(incr);
1934  swig_unary_op(decr);
1935 
1936  swig_binary_op(add);
1937  swig_binary_op(sub);
1938  swig_binary_op(mul);
1939  swig_binary_op(div);
1940  swig_binary_op(pow);
1941  swig_binary_op(ldiv);
1942  swig_binary_op(lshift);
1943  swig_binary_op(rshift);
1944  swig_binary_op(lt);
1945  swig_binary_op(le);
1946  swig_binary_op(eq);
1947  swig_binary_op(ge);
1948  swig_binary_op(gt);
1949  swig_binary_op(ne);
1950  swig_binary_op(el_mul);
1951  swig_binary_op(el_div);
1952  swig_binary_op(el_pow);
1953  swig_binary_op(el_ldiv);
1954  swig_binary_op(el_and);
1955  swig_binary_op(el_or);
1956 
1958  swigreg_unary_op(not);
1959  swigreg_unary_op(uplus);
1960  swigreg_unary_op(uminus);
1961  swigreg_unary_op(transpose);
1962  swigreg_unary_op(hermitian);
1963  swigreg_unary_op(incr);
1964  swigreg_unary_op(decr);
1965  }
1966  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
1967  swigreg_binary_op(add);
1968  swigreg_binary_op(sub);
1969  swigreg_binary_op(mul);
1970  swigreg_binary_op(div);
1971  swigreg_binary_op(pow);
1972  swigreg_binary_op(ldiv);
1973  swigreg_binary_op(lshift);
1974  swigreg_binary_op(rshift);
1975  swigreg_binary_op(lt);
1976  swigreg_binary_op(le);
1977  swigreg_binary_op(eq);
1978  swigreg_binary_op(ge);
1979  swigreg_binary_op(gt);
1980  swigreg_binary_op(ne);
1981  swigreg_binary_op(el_mul);
1982  swigreg_binary_op(el_div);
1983  swigreg_binary_op(el_pow);
1984  swigreg_binary_op(el_ldiv);
1985  swigreg_binary_op(el_and);
1986  swigreg_binary_op(el_or);
1987  }
1989  // here we assume that tid are conseq integers increasing from zero, and
1990  // that our tid is the last one. might be better to have explicit string
1991  // list of types we should bind to, and use lookup_type to resolve their tid.
1992 
1993  SWIG_InstallUnaryOps(tid);
1994  SWIG_InstallBinaryOps(tid, tid);
1995  for (int j = 0; j < tid; ++j) {
1996  SWIG_InstallBinaryOps(j, tid);
1997  SWIG_InstallBinaryOps(tid, j);
1998  }
1999  }
2000 
2001 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2002  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2003 
2004 #ifdef SWIG_DIRECTORS
2005  Swig::Director *d = Swig::get_rtdir(ptr);
2006  if (d && Swig::swig_director_get_self(d))
2007  return Swig::swig_director_get_self(d)->as_value();
2008 #endif
2009  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2010 }
2011 
2012 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2013  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2014  ov = ov.cell_value()(0);
2015  if (!ov.is_defined() ||
2016  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2017  if (ptr)
2018  *ptr = 0;
2019  return SWIG_OK;
2020  }
2021  if (ov.type_id() != octave_swig_ref::static_type_id())
2022  return SWIG_ERROR;
2023  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2024  octave_swig_type *ost = osr->get_ptr();
2025  void *vptr = ost->cast(type, own, flags);
2026  if (!vptr)
2027  return SWIG_ERROR;
2028  if (ptr)
2029  *ptr = vptr;
2030  return SWIG_OK;
2031 }
2032 
2033 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2034  return new octave_swig_packed(type, (char *) ptr, sz);
2035 }
2036 
2037 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2038  if (!ov.is_defined())
2039  return SWIG_ERROR;
2040  if (ov.type_id() != octave_swig_packed::static_type_id())
2041  return SWIG_ERROR;
2042  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2043  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2044 }
2045 
2046 void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2047  module_ns->assign(name, ov);
2048 }
2049 
2050 SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
2051  return get_global_value(name, true);
2052 }
2053 
2054 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2055  // It is critical that a newly-allocated octave_value is passed to set_global_value(),
2056  // since it and the Octave symbol table take references to the values assigned to it.
2057  // If we were to pass a reference to 'value' to set_global_value(), then the Octave
2058  // symbol table would hold a reference to a variable owned by the SWIG .oct module.
2059  // Both will think that they own the reference (since the .oct module is dynamically
2060  // loaded, it appears to have its own C++ runtime), and so they will both try to
2061  // de-allocate the octave_value on exit, resulting in a double-free or seg-fault.
2062  // This is prevented by giving Octave its own heap-allocated copy of 'value'.
2063  octave_value *pov = new octave_value(value);
2064  set_global_value(name, *pov);
2065 }
2066 
2068 #if OCTAVE_API_VERSION_NUMBER < 37
2069  link_to_global_variable(curr_sym_tab->lookup(name, true));
2070 #else
2071  symbol_table::varref(name);
2072  symbol_table::mark_global(name);
2073 #endif
2074 }
2075 
2077  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2078  if (!ov.is_defined() ||
2079  ov.type_id() != octave_swig_packed::static_type_id())
2080  return 0;
2081  const octave_swig_packed* osp =
2082  static_cast < const octave_swig_packed *> (ov.internal_rep());
2083  swig_module_info *pointer = 0;
2084  osp->copy(0, &pointer, sizeof(swig_module_info *));
2085  return pointer;
2086 }
2087 
2088 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2089  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2091 }
2092 
2093 
2094 
2095 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2096 
2097 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2098 
2099 
2100 
2101 /* -------- TYPES TABLE (BEGIN) -------- */
2102 
2103 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2104 #define SWIGTYPE_p_char swig_types[1]
2105 #define SWIGTYPE_p_double swig_types[2]
2106 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2107 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2108 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2109 #define SWIGTYPE_p_int swig_types[6]
2110 #define SWIGTYPE_p_p_char swig_types[7]
2111 #define SWIGTYPE_p_unsigned_int swig_types[8]
2113 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2114 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2115 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2116 
2117 /* -------- TYPES TABLE (END) -------- */
2118 
2119 
2120 #define SWIGVERSION 0x020007
2121 #define SWIG_VERSION SWIGVERSION
2122 
2123 
2124 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2125 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2126 
2127 
2128 #include <stdexcept>
2129 
2130 
2131 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2132 #undef PACKAGE
2133 #undef VERSION
2134 
2135 #include "plplotP.h"
2136 
2137 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2138 #ifdef OCTAVE_EXPORT
2139  #if defined ( __GNUC__ ) && __GNUC__ > 3
2140  #undef OCTAVE_EXPORT
2141  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2142  #endif
2143 #endif
2144 
2145 
2146 
2147 // I hate global variables but this is the best way I can think of
2148 // to manage consistency checking among function arguments.
2149  static PLINT Alen = 0;
2150  static PLINT Xlen = 0, Ylen = 0;
2151 
2152 
2153 // Convenience functions copied from matwrap-based approach (currently
2154 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2155 // tricky scalar case and also adopted so that the resulting
2156 // swig-generated source code will look similar to the matwrap-generated
2157 // source code.
2158 
2159  inline int max( int a, int b )
2160  {
2161  return a >= b ? a : b;
2162  }
2163  inline int min( int a, int b )
2164  {
2165  return a >= b ? a : b;
2166  }
2167 
2168 //
2169 // Function to get the total length (rows*columns) of an octave object of
2170 // arbitrary type.
2171 // Arguments:
2172 // 1) The octave object.
2173 //
2174 // If the object is a scalar, the array length is 1.
2175 //
2176  static int
2177  _arraylen( const octave_value &o_obj )
2178  {
2179  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2180  // max is necessary because sometimes
2181  // rows() or columns() return -1 or 0 for
2182  // scalars.
2183  }
2184 
2185 //
2186 // Function to get the number of dimensions of an object.
2187 //
2188  static int
2189  _n_dims( const octave_value &o_obj )
2190  {
2191  if ( max( o_obj.columns(), 1 ) > 1 )
2192  return 2;
2193  // max is necessary because sometimes
2194  // rows() or columns() return -1 or 0 for
2195  // scalars.
2196  else if ( max( o_obj.rows(), 1 ) > 1 )
2197  return 1;
2198  else
2199  return 0;
2200  }
2201 
2202 //
2203 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2204 //
2205  static inline int
2206  _dim( const octave_value &o_obj, int dim_idx )
2207  {
2208  if ( dim_idx == 0 )
2209  return max( o_obj.rows(), 0 );
2210  // max is necessary because sometimes
2211  // rows() or columns() return -1 or 0 for
2212  // scalars.
2213  else if ( dim_idx == 1 )
2214  return max( o_obj.columns(), 0 );
2215  else
2216  return 1;
2217  }
2218 
2219 //
2220 // The following function converts an array of doubles into some other
2221 // numeric type. Arguments:
2222 // 1) Where to store the result. The type is determined from the type of
2223 // this pointer.
2224 // 2) A vector of doubles to convert.
2225 // 3) The number of doubles.
2226 //
2227  template <class FLOAT>
2228  static inline void
2229  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2230  {
2231  while ( n_el-- > 0 )
2232  *out_arr++ = (FLOAT) ( *in_arr++ );
2233  }
2234 
2235  template void _cvt_double_to( int *, double *, unsigned );
2236  template void _cvt_double_to( unsigned *, double *, unsigned );
2237  template void _cvt_double_to( long *, double *, unsigned );
2238  template void _cvt_double_to( unsigned long *, double *, unsigned );
2239  template void _cvt_double_to( short *, double *, unsigned );
2240  template void _cvt_double_to( unsigned short *, double *, unsigned );
2241  template void _cvt_double_to( float *, double *, unsigned );
2242  // Instantiate our templates. Octave uses
2243  // manual template instantiation.
2244 
2245 //
2246 // Convert an array of some other type into an array of doubles. Arguments:
2247 // 1) The array of objects of other type.
2248 // 2) The output array of doubles.
2249 // 3) The number of elements to convert.
2250 //
2251  template <class FLOAT>
2252  static inline void
2253  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2254  {
2255  while ( n_el-- > 0 )
2256  *d_arr++ = double(*arr++);
2257  }
2258 
2259  template void _cvt_to_double( int *, double *, unsigned );
2260  template void _cvt_to_double( unsigned *, double *, unsigned );
2261  template void _cvt_to_double( long *, double *, unsigned );
2262  template void _cvt_to_double( unsigned long *, double *, unsigned );
2263  template void _cvt_to_double( short *, double *, unsigned );
2264  template void _cvt_to_double( unsigned short *, double *, unsigned );
2265  template void _cvt_to_double( float *, double *, unsigned );
2266  // Instantiate our templates. Octave uses
2267  // manual template instantiation.
2268 
2269 
2270  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2271  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2272  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2273  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2274  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2276  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2277 
2278 
2279 #include <iostream>
2280 
2281  octave_function *fcnMapForm;
2282  std::string nameMapForm;
2283 
2284  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2285  {
2286  octave_idx_type i;
2287  octave_value_list functionArguments;
2288  octave_value_list retval;
2289 
2290  Matrix xin( n, 1 );
2291  Matrix yin( n, 1 );
2292  Matrix xout;
2293  Matrix yout;
2294 
2295  for ( i = 0; i < n; i++ )
2296  {
2297  xin( i, 0 ) = x[i];
2298  yin( i, 0 ) = y[i];
2299  }
2300 
2301  functionArguments( 0 ) = xin;
2302  functionArguments( 1 ) = yin;
2303 
2304  if ( fcnMapForm != NULL )
2305  retval = feval( fcnMapForm, functionArguments, 1 );
2306  else
2307  retval = feval( nameMapForm, functionArguments, 1 );
2308 
2309 
2310  if ( retval.length() >= 2 )
2311  {
2312  xout = retval( 0 ).matrix_value();
2313  yout = retval( 1 ).matrix_value();
2314 
2315  for ( i = 0; i < n; i++ )
2316  {
2317  x[i] = xout( i, 0 );
2318  y[i] = yout( i, 0 );
2319  }
2320  }
2321  }
2322 
2323 
2324  octave_function *fcnLabelFunc;
2325  std::string nameLabelFunc;
2326 
2327  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2328  {
2329  int i;
2330  octave_value_list functionArguments;
2331  octave_value_list retval;
2332 
2333  Matrix inAxis( 1, 1 );
2334  Matrix inValue( 1, 1 );
2335  inAxis( 0, 0 ) = axis;
2336  inValue( 0, 0 ) = value;
2337 
2338  functionArguments( 0 ) = inAxis;
2339  functionArguments( 1 ) = inValue;
2340 
2341  if ( fcnLabelFunc != NULL )
2342  retval = feval( fcnLabelFunc, functionArguments, 1 );
2343  else
2344  retval = feval( nameLabelFunc, functionArguments, 1 );
2345 
2346  strncpy( label, retval( 0 ).string_value().c_str(), length );
2347  }
2348 
2349 
2350  octave_function *fcnCoordTrans;
2351  std::string nameCoordTrans;
2352 
2353  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2354  {
2355  octave_idx_type i;
2356  octave_value_list functionArguments;
2357  octave_value_list retval;
2358 
2359  Matrix xin( 1, 1 );
2360  Matrix yin( 1, 1 );
2361  Matrix xout;
2362  Matrix yout;
2363 
2364  xin( 0, 0 ) = x;
2365  yin( 0, 0 ) = y;
2366 
2367  functionArguments( 0 ) = xin;
2368  functionArguments( 1 ) = yin;
2369 
2370  if ( fcnCoordTrans != NULL )
2371  retval = feval( fcnCoordTrans, functionArguments, 1 );
2372  else
2373  retval = feval( nameCoordTrans, functionArguments, 1 );
2374 
2375 
2376  if ( retval.length() >= 2 )
2377  {
2378  xout = retval( 0 ).matrix_value();
2379  yout = retval( 1 ).matrix_value();
2380 
2381  *xt = xout( 0, 0 );
2382  *yt = yout( 0, 0 );
2383  }
2384  }
2385 
2386 
2387  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2388  {
2389  PLINT i;
2390  printf( "nlegend =%d\n", nlegend );
2391  for ( i = 0; i < nlegend; i++ )
2392  {
2393  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2394  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2395  printf( "text[%d] =%s\n", i, text[i] );
2396  }
2397  }
2398 
2399 
2400 #include <limits.h>
2401 #if !defined(SWIG_NO_LLONG_MAX)
2402 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2403 # define LLONG_MAX __LONG_LONG_MAX__
2404 # define LLONG_MIN (-LLONG_MAX - 1LL)
2405 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2406 # endif
2407 #endif
2408 
2409 
2410  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2411  {
2412  if (!ov.is_scalar_type())
2413  return SWIG_TypeError;
2414  if (ov.is_complex_scalar())
2415  return SWIG_TypeError;
2416  if (ov.is_double_type()||ov.is_single_type()) {
2417  double v=ov.double_value();
2418  if (v!=floor(v))
2419  return SWIG_TypeError;
2420  }
2421  if (val)
2422  *val = ov.long_value();
2423  return SWIG_OK;
2424  }
2425 
2426 
2427 SWIGINTERN int
2428 SWIG_AsVal_int (octave_value obj, int *val)
2429 {
2430  long v;
2431  int res = SWIG_AsVal_long (obj, &v);
2432  if (SWIG_IsOK(res)) {
2433  if ((v < INT_MIN || v > INT_MAX)) {
2434  return SWIG_OverflowError;
2435  } else {
2436  if (val) *val = (int)(v);
2437  }
2438  }
2439  return res;
2440 }
2441 
2442 
2443  static int my_plGetCursor( int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin )
2444  {
2445  PLGraphicsIn gin;
2446  int status; status = plGetCursor( &gin );
2447  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2448  strncpy( string, gin.string, PL_MAXKEY - 1 );
2449  string[PL_MAXKEY - 1] = '\0';
2450 
2451  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2452  return status;
2453  }
2454 
2455 
2456 SWIGINTERN int
2457 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2458 {
2459  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2460  ov = ov.cell_value()(0);
2461  if (!ov.is_string())
2462  return SWIG_TypeError;
2463 
2464  std::string str=ov.string_value();
2465  size_t len=str.size();
2466  char* cstr=(char*)str.c_str();
2467  if (alloc) {
2468  *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2469  *alloc = SWIG_NEWOBJ;
2470  } else if (cptr)
2471  *cptr = cstr;
2472  if (psize)
2473  *psize = len + 1;
2474  return SWIG_OK;
2475 }
2476 
2477 
2478 
2479 
2480 
2482  {
2483  return octave_value(value);
2484  }
2485 
2486 
2487 SWIGINTERNINLINE octave_value
2489 {
2490  return SWIG_From_long (value);
2491 }
2492 
2493 
2495  {
2496  return octave_value(value);
2497  }
2498 
2499 
2500 // Translates relative device coordinates to world coordinates.
2501  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2502  {
2503  PLGraphicsIn gin;
2504  int st;
2505  gin.dX = x_in; gin.dY = y_in;
2506  st = plTranslateCursor( &gin );
2507  *x = gin.wX; *y = gin.wY;
2508  return st;
2509  }
2510 
2511 
2512  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2513  {
2514  if (!ov.is_scalar_type())
2515  return SWIG_TypeError;
2516  if (ov.is_complex_scalar())
2517  return SWIG_TypeError;
2518  if (val)
2519  *val = ov.double_value();
2520  return SWIG_OK;
2521  }
2522 
2523 
2524 // Create 1d stripchart
2525 
2526  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2527  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2528  PLFLT xlpos, PLFLT ylpos,
2529  PLBOOL y_ascl, PLBOOL acc,
2530  PLINT colbox, PLINT collab,
2531  const PLINT *colline, const PLINT *styline,
2532  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2533  const char *labx, const char *laby, const char *labtop )
2534  {
2535  const char *legline[4];
2536  legline[0] = legline1; legline[1] = legline2;
2537  legline[2] = legline3; legline[3] = legline4;
2538  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2539  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2540  labx, laby, labtop );
2541  }
2542 
2543 
2544 // One more hack. As it is not possible (and would not be desirable) to pass
2545 // an Octave function to plcont(), I have defined three plcont():
2546 // plcont uses a defined here xform()
2547 // plcont0 uses pltr0()
2548 // plcont1 uses pltr1()
2549 // plcont2 uses pltr2()
2550 // plcont2p uses pltr2p()
2551 //
2552 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2553 // f2c, which is a #define that does the necessary conversion.
2554 //
2555 
2556  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2557  {
2558  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2559  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2560  }
2561 
2562 // convert from Fortran like arrays (one vector), to C like 2D arrays
2563 
2564 #define f2c( f, ff, nx, ny ) \
2565  PLFLT * *ff; \
2566  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2567  for ( int i = 0; i < nx; i++ ) { \
2568  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2569  for ( int j = 0; j < ny; j++ ) \
2570  *( ff[i] + j ) = *( f + nx * j + i );}
2571 
2572 // simpler plcont() for use with xform()
2573 
2574  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2575  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2576  {
2577  f2c( f, ff, nx, ny );
2578  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2579  }
2580 
2581 // plcont() for use with pltr0() NOT TESTED
2582 
2583  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2584  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2585  {
2586  f2c( f, ff, nx, ny );
2587  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2588  }
2589 
2590 // plcont() for use with pltr1()
2591 
2592  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2593  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2594  {
2595  PLcGrid grid1;
2596  grid1.nx = nx; grid1.ny = ny;
2597  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2598  f2c( f, ff, nx, ny );
2599  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2600  }
2601 
2602 // plcont() for use with pltr2()
2603  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2604  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2605  {
2606  PLcGrid2 grid2;
2607  f2c( xg, xgg, nx, ny );
2608  f2c( yg, ygg, nx, ny );
2609  grid2.nx = nx; grid2.ny = ny;
2610  grid2.xg = xgg; grid2.yg = ygg;
2611  f2c( f, ff, nx, ny );
2612  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2613  }
2614 
2615 // plcont() for use with pltr2p()
2616 
2617  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2618  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2619  {
2620  PLcGrid2 grid2;
2621  f2c( xg, xgg, nx, ny );
2622  f2c( yg, ygg, nx, ny );
2623  grid2.nx = nx; grid2.ny = ny;
2624  grid2.xg = xgg; grid2.yg = ygg;
2625  f2c( f, ff, nx, ny );
2626  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2627  }
2628 
2629 
2630  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2631  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2632  PLFLT *zg, int type, PLFLT data )
2633  {
2634  f2c( zg, zgg, nptsx, nptsy );
2635  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2636  for ( int i = 0; i < nptsx; i++ )
2637  for ( int j = 0; j < nptsy; j++ )
2638  *( zg + nptsx * j + i ) = zgg[i][j];
2639  }
2640 
2641 
2642 // Plots a mesh representation of the function z[x][y].
2643 
2644  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2645  {
2646  f2c( z, zz, nx, ny );
2647  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
2648  }
2649 
2650 // Plots a mesh representation of the function z[x][y] with contour
2651 
2652  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2653  {
2654  f2c( z, zz, nx, ny );
2655  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2656  }
2657 
2658 
2659 // Plots a 3-d representation of the function z[x][y].
2660  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2661  PLINT nx, PLINT ny, PLINT opt, PLINT side )
2662  {
2663  f2c( z, zz, nx, ny );
2664  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
2665  }
2666 
2667 // Plots a 3-d representation of the function z[x][y] with contour
2668  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2669  PLINT nx, PLINT ny, PLINT opt,
2670  const PLFLT *clevel, PLINT nlevel )
2671  {
2672  f2c( z, zz, nx, ny );
2673  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2674  }
2675 // Plots a 3-d representation of the function z[x][y] with contour with y
2676 // index limits
2677  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
2678  PLINT nx, PLINT ny, PLINT opt,
2679  const PLFLT * clevel, PLINT nlevel,
2680  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
2681  {
2682  f2c( z, zz, nx, ny );
2683  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2684  indexxmin, indexxmax, indexymin, indexymax );
2685  }
2686 
2687 
2688  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2689  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2690  {
2691  f2c( z, zz, nx, ny );
2692  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2693  }
2694 
2695  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
2696  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
2697  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
2698  {
2699  f2c( z, zz, nx, ny );
2700  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2701  indexxmin, indexxmax, indexymin, indexymax );
2702  }
2703 
2704 
2705 // The same as in plcont. I have hardcoded the first function pointer
2706 // to plfill(). The second function pointer will use the same convention
2707 // as in plcont().
2708 //
2709 
2710 // the simpler plshade()
2711  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
2712  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2713  PLFLT shade_min, PLFLT shade_max,
2714  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2715  PLINT min_color, PLINT min_width,
2716  PLINT max_color, PLINT max_width,
2717  PLINT rectangular, PLFLT *tr )
2718  {
2719  f2c( a, aa, nx, ny );
2720  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2721  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2722  min_color, min_width, max_color, max_width,
2723  plfill, rectangular, xform, tr );
2724  }
2725 
2726 // plshade() for use with pltr1
2727  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2728  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2729  PLFLT shade_min, PLFLT shade_max,
2730  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2731  PLINT min_color, PLINT min_width,
2732  PLINT max_color, PLINT max_width,
2733  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2734  {
2735  PLcGrid grid1;
2736  grid1.nx = nx; grid1.ny = ny;
2737  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2738  f2c( a, aa, nx, ny );
2739  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2740  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2741  min_color, min_width, max_color, max_width,
2742  plfill, rectangular, pltr1, &grid1 );
2743  }
2744 
2745 // plshade() for use with pltr2
2746  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2747  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2748  PLFLT shade_min, PLFLT shade_max,
2749  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2750  PLINT min_color, PLINT min_width,
2751  PLINT max_color, PLINT max_width,
2752  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2753  {
2754  PLcGrid2 grid2;
2755  f2c( xg, xgg, nx, ny );
2756  f2c( yg, ygg, nx, ny );
2757  grid2.nx = nx; grid2.ny = ny;
2758  grid2.xg = xgg; grid2.yg = ygg;
2759  f2c( a, aa, nx, ny );
2760  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2761  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2762  min_color, min_width, max_color, max_width,
2763  plfill, rectangular, pltr2, &grid2 );
2764  }
2765 
2766 
2767 
2768  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
2769  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2770  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2771  PLINT cont_color, PLINT cont_width,
2772  PLINT rectangular )
2773  {
2774  f2c( a, aa, nx, ny );
2775  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2776  clevel, nlevel, fill_width, cont_color, cont_width,
2777  plfill, rectangular, NULL, NULL );
2778  }
2779 
2780  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
2781  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2782  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2783  PLINT cont_color, PLINT cont_width,
2784  PLINT rectangular, PLFLT *tr )
2785  {
2786  f2c( a, aa, nx, ny );
2787  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2788  clevel, nlevel, fill_width, cont_color, cont_width,
2789  plfill, rectangular, xform, tr );
2790  }
2791 
2792  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
2793  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2794  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2795  PLINT cont_color, PLINT cont_width,
2796  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2797  {
2798  PLcGrid grid1;
2799  grid1.nx = nx; grid1.ny = ny;
2800  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2801 
2802  f2c( a, aa, nx, ny );
2803  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2804  clevel, nlevel, fill_width, cont_color, cont_width,
2805  plfill, rectangular, pltr1, &grid1 );
2806  }
2807 
2808  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
2809  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2810  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2811  PLINT cont_color, PLINT cont_width,
2812  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2813  {
2814  PLcGrid2 grid2;
2815  f2c( xg, xgg, nx, ny );
2816  f2c( yg, ygg, nx, ny );
2817  grid2.nx = nx; grid2.ny = ny;
2818  grid2.xg = xgg; grid2.yg = ygg;
2819  f2c( a, aa, nx, ny );
2820  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2821  clevel, nlevel, fill_width, cont_color, cont_width,
2822  plfill, rectangular, pltr2, &grid2 );
2823  }
2824 
2825 
2826 // Plot an array of vector arrows - uses the same function pointer
2827 // convention as plcont
2828 
2829  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2830  {
2831  f2c( u, uu, nx, ny );
2832  f2c( v, vv, nx, ny );
2833  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
2834  }
2835 
2836 // plvect() for use with pltr1
2837  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2838  {
2839  PLcGrid grid1;
2840  grid1.nx = nx; grid1.ny = ny;
2841  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2842  f2c( u, uu, nx, ny );
2843  f2c( v, vv, nx, ny );
2844  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
2845  }
2846 
2847 // plvect() for use with pltr2
2848  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2849  {
2850  PLcGrid2 grid2;
2851  f2c( xg, xgg, nx, ny );
2852  f2c( yg, ygg, nx, ny );
2853  grid2.nx = nx; grid2.ny = ny;
2854  grid2.xg = xgg; grid2.yg = ygg;
2855  f2c( u, uu, nx, ny );
2856  f2c( v, vv, nx, ny );
2857  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
2858  }
2859 
2860 
2861 // Plot an image with distortion - uses the same function pointer
2862  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
2863  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2864  PLFLT zmin, PLFLT zmax,
2865  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2866  {
2867  f2c( a, aa, nx, ny );
2868  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2869  }
2870 
2871 // Plot an image with distortion - uses the same function pointer
2872 // convention as plcont
2873  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
2874  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2875  PLFLT zmin, PLFLT zmax,
2876  PLFLT valuemin, PLFLT valuemax )
2877  {
2878  f2c( a, aa, nx, ny );
2879  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2880  }
2881 
2882  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
2883  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2884  PLFLT zmin, PLFLT zmax,
2885  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2886  {
2887  f2c( a, aa, nx, ny );
2888  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
2889  }
2890 
2891 // plimagefr() for use with pltr1
2892  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
2893  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2894  PLFLT zmin, PLFLT zmax,
2895  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2896  {
2897  PLcGrid grid1;
2898  grid1.nx = nx + 1; grid1.ny = ny + 1;
2899  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2900  f2c( a, aa, nx, ny );
2901  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
2902  }
2903 
2904 // plimagefr() for use with pltr2
2905  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
2906  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2907  PLFLT zmin, PLFLT zmax,
2908  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2909  {
2910  PLcGrid2 grid2;
2911  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
2912  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2913  grid2.nx = nx + 1; grid2.ny = ny + 1;
2914  grid2.xg = xgg; grid2.yg = ygg;
2915  f2c( a, aa, nx, ny );
2916  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
2917  }
2918 
2919 
2920 
2921  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
2922  PLINT opt, PLINT position, PLFLT x, PLFLT y,
2923  PLFLT x_length, PLFLT y_length,
2924  PLINT bg_color, PLINT bb_color, PLINT bb_style,
2925  PLFLT low_cap_color, PLFLT high_cap_color,
2926  PLINT cont_color, PLFLT cont_width,
2927  PLINT n_labels, const PLINT *label_opts, const char **label,
2928  PLINT n_axes, const char ** axis_opts,
2929  const PLFLT *ticks, const PLINT *sub_ticks,
2930  const PLINT *n_values, const PLFLT *a )
2931  {
2932  PLINT nx, ny, i;
2933  nx = n_axes;
2934  ny = -1;
2935  for ( i = 0; i < nx; i++ )
2936  if ( n_values[i] > ny )
2937  ny = n_values[i];
2938  f2c( a, aa, nx, ny );
2939  c_plcolorbar( p_colorbar_width, p_colorbar_height,
2940  opt, position, x, y,
2941  x_length, y_length,
2942  bg_color, bb_color, bb_style,
2943  low_cap_color, high_cap_color,
2944  cont_color, cont_width,
2945  n_labels, label_opts, label,
2946  n_axes, axis_opts,
2947  ticks, sub_ticks,
2948  n_values, aa );
2949  }
2950 
2951 
2952 
2953  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
2954  {
2955  if (!ov.is_scalar_type())
2956  return SWIG_TypeError;
2957  if (ov.is_complex_scalar())
2958  return SWIG_TypeError;
2959  if (ov.is_double_type()||ov.is_single_type()) {
2960  double v=ov.double_value();
2961  if (v<0)
2962  return SWIG_OverflowError;
2963  if (v!=floor(v))
2964  return SWIG_TypeError;
2965  }
2966  if (ov.is_int8_type()||ov.is_int16_type()||
2967  ov.is_int32_type()) {
2968  long v=ov.long_value();
2969  if (v<0)
2970  return SWIG_OverflowError;
2971  }
2972  if (ov.is_int64_type()) {
2973  long long v=ov.int64_scalar_value().value();
2974  if (v<0)
2975  return SWIG_OverflowError;
2976  }
2977  if (val)
2978  *val = ov.ulong_value();
2979  return SWIG_OK;
2980  }
2981 
2982 
2983 SWIGINTERN int
2984 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
2985 {
2986  unsigned long v;
2987  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2988  if (SWIG_IsOK(res)) {
2989  if ((v > UINT_MAX)) {
2990  return SWIG_OverflowError;
2991  } else {
2992  if (val) *val = (unsigned int)(v);
2993  }
2994  }
2995  return res;
2996 }
2997 
2998 
3000  {
3001  return octave_value(value);
3002  }
3003 
3004 
3005 SWIGINTERNINLINE octave_value
3007 {
3008  return SWIG_From_unsigned_SS_long (value);
3009 }
3010 
3011 
3012 SWIGINTERN int
3013 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3014 {
3015  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3016  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3017  if (SWIG_IsOK(res)) {
3018  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3019  if (csize <= size) {
3020  if (val) {
3021  if (csize) memcpy(val, cptr, csize*sizeof(char));
3022  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3023  }
3024  if (alloc == SWIG_NEWOBJ) {
3025  delete[] cptr;
3026  res = SWIG_DelNewMask(res);
3027  }
3028  return res;
3029  }
3030  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3031  }
3032  return SWIG_TypeError;
3033 }
3034 
3035 
3038 {
3039  static int init = 0;
3040  static swig_type_info* info = 0;
3041  if (!init) {
3042  info = SWIG_TypeQuery("_p_char");
3043  init = 1;
3044  }
3045  return info;
3046 }
3047 
3048 
3049 SWIGINTERNINLINE octave_value
3050 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3051 {
3052  return std::string(carray,carray+size);
3053 }
3054 
3055 
3056 SWIGINTERN int
3057 SWIG_AsVal_char (octave_value obj, char *val)
3058 {
3059  int res = SWIG_AsCharArray(obj, val, 1);
3060  if (!SWIG_IsOK(res)) {
3061  long v;
3062  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3063  if (SWIG_IsOK(res)) {
3064  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3065  if (val) *val = (char)(v);
3066  } else {
3067  res = SWIG_OverflowError;
3068  }
3069  }
3070  }
3071  return res;
3072 }
3073 
3074 const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3075 Specify viewport in absolute coordinates \n\
3076 \n\
3077 DESCRIPTION:\n\
3078 \n\
3079  Alternate routine to plvpor for setting up the viewport. This routine\n\
3080  should be used only if the viewport is required to have a definite\n\
3081  size in millimeters. The routine plgspa is useful for finding out the\n\
3082  size of the current subpage. \n\
3083 \n\
3084  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3085 \n\
3086  This function is used in example 10. \n\
3087 \n\
3088 \n\
3089 \n\
3090 SYNOPSIS:\n\
3091 \n\
3092 plsvpa(xmin, xmax, ymin, ymax)\n\
3093 \n\
3094 ARGUMENTS:\n\
3095 \n\
3096  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3097  viewport from the left-hand edge of the subpage in millimeters. \n\
3098 \n\
3099  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3100  viewport from the left-hand edge of the subpage in millimeters. \n\
3101 \n\
3102  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3103  viewport from the bottom edge of the subpage in millimeters. \n\
3104 \n\
3105  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3106  from the bottom edge of the subpage in millimeters. \n\
3107 ";
3108 const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3109 Write text relative to viewport boundaries in 3D plots \n\
3110 \n\
3111 DESCRIPTION:\n\
3112 \n\
3113  Writes text at a specified position relative to the viewport\n\
3114  boundaries. Text may be written inside or outside the viewport, but\n\
3115  is clipped at the subpage boundaries. The reference point of a string\n\
3116  lies along a line passing through the string at half the height of a\n\
3117  capital letter. The position of the reference point along this line\n\
3118  is determined by just, and the position of the reference point\n\
3119  relative to the viewport is set by disp and pos. \n\
3120 \n\
3121  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3122 \n\
3123  This function is used in example 28. \n\
3124 \n\
3125 \n\
3126 \n\
3127 SYNOPSIS:\n\
3128 \n\
3129 plmtex3(side, disp, pos, just, text)\n\
3130 \n\
3131 ARGUMENTS:\n\
3132 \n\
3133  side (const char *, input) : Specifies the side of the viewport\n\
3134  along which the text is to be written. The string should contain\n\
3135  one or more of the following characters: [xyz][ps][v]. Only one\n\
3136  label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3137  both the X and Y axes. x: Label the X axis. \n\
3138  y: Label the Y axis. \n\
3139  z: Label the Z axis. \n\
3140  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3141  For X it is the axis that starts at y-min. For Y it is the\n\
3142  axis that starts at x-min. \n\
3143  s: Label the secondary axis. \n\
3144  v: Draw the text perpendicular to the axis. \n\
3145 \n\
3146 \n\
3147  disp (PLFLT, input) : Position of the reference point of string,\n\
3148  measured outwards from the specified viewport edge in units of the\n\
3149  current character height. Use negative disp to write within the\n\
3150  viewport. \n\
3151 \n\
3152  pos (PLFLT, input) : Position of the reference point of string\n\
3153  along the specified edge, expressed as a fraction of the length of\n\
3154  the edge. \n\
3155 \n\
3156  just (PLFLT, input) : Specifies the position of the string relative\n\
3157  to its reference point. If just=0. , the reference point is at\n\
3158  the left and if just=1. , it is at the right of the string. Other\n\
3159  values of just give intermediate justifications. \n\
3160 \n\
3161  text (const char *, input) : The string to be written out. \n\
3162 ";
3163 const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3164 Set cmap1 colors using 8-bit RGB values and double alpha transparency values \n\
3165 \n\
3166 DESCRIPTION:\n\
3167 \n\
3168  Set cmap1 colors using 8-bit RGB values (see the PLplot documentation)\n\
3169  and double alpha transparency values. This also sets the number of\n\
3170  colors. \n\
3171 \n\
3172  Redacted form: plscmap1a(r, g, b, alpha)\n\
3173 \n\
3174  This function is used in example 31. \n\
3175 \n\
3176 \n\
3177 \n\
3178 SYNOPSIS:\n\
3179 \n\
3180 plscmap1a(r, g, b, alpha, ncol1)\n\
3181 \n\
3182 ARGUMENTS:\n\
3183 \n\
3184  r (const PLINT *, input) : Pointer to array with set of unsigned\n\
3185  8-bit integers (0-255) representing the degree of red in the\n\
3186  color. \n\
3187 \n\
3188  g (const PLINT *, input) : Pointer to array with set of unsigned\n\
3189  8-bit integers (0-255) representing the degree of green in the\n\
3190  color. \n\
3191 \n\
3192  b (const PLINT *, input) : Pointer to array with set of unsigned\n\
3193  8-bit integers (0-255) representing the degree of blue in the\n\
3194  color. \n\
3195 \n\
3196  alpha (const PLFLT *, input) : Pointer to array with set of double\n\
3197  values (0.0-1.0) representing the alpha transparency value of the\n\
3198  color. \n\
3199 \n\
3200  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3201  arrays. \n\
3202 ";
3203 const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3204 Select standard viewport \n\
3205 \n\
3206 DESCRIPTION:\n\
3207 \n\
3208  Sets up a standard viewport, leaving a left-hand margin of seven\n\
3209  character heights, and four character heights around the other three\n\
3210  sides. \n\
3211 \n\
3212  Redacted form: plvsta()\n\
3213 \n\
3214  This function is used in examples 1,12,14,17,25,29. \n\
3215 \n\
3216 \n\
3217 \n\
3218 SYNOPSIS:\n\
3219 \n\
3220 plvsta()\n\
3221 ";
3222 const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3223 Switch to graphics screen \n\
3224 \n\
3225 DESCRIPTION:\n\
3226 \n\
3227  Sets an interactive device to graphics mode, used in conjunction with\n\
3228  pltext to allow graphics and text to be interspersed. On a device\n\
3229  which supports separate text and graphics windows, this command causes\n\
3230  control to be switched to the graphics window. If already in graphics\n\
3231  mode, this command is ignored. It is also ignored on devices which\n\
3232  only support a single window or use a different method for shifting\n\
3233  focus. See also pltext. \n\
3234 \n\
3235  Redacted form: plgra()\n\
3236 \n\
3237  This function is used in example 1. \n\
3238 \n\
3239 \n\
3240 \n\
3241 SYNOPSIS:\n\
3242 \n\
3243 plgra()\n\
3244 ";
3245 const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3246 Set 8-bit RGB values and double alpha transparency value for given cmap0 color index \n\
3247 \n\
3248 DESCRIPTION:\n\
3249 \n\
3250  Set 8-bit RGB value and double alpha transparency value for given\n\
3251  cmap0 (see the PLplot documentation) index. Overwrites the previous\n\
3252  color value for the given index and, thus, does not result in any\n\
3253  additional allocation of space for colors. \n\
3254 \n\
3255  This function is used in example 30. \n\
3256 \n\
3257 \n\
3258 \n\
3259 SYNOPSIS:\n\
3260 \n\
3261 plscol0a(icol0, r, g, b, alpha)\n\
3262 \n\
3263 ARGUMENTS:\n\
3264 \n\
3265  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3266  number of colors (which is set by default, by plscmap0n, or even\n\
3267  by plscmap0). \n\
3268 \n\
3269  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3270  degree of red in the color. \n\
3271 \n\
3272  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3273  degree of green in the color. \n\
3274 \n\
3275  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3276  degree of blue in the color. \n\
3277 \n\
3278  alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
3279  alpha transparency value of the color. \n\
3280 ";
3281 const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3282 Set y axis parameters \n\
3283 \n\
3284 DESCRIPTION:\n\
3285 \n\
3286  Identical to plsxax, except that arguments are flags for y axis. See\n\
3287  the description of plsxax for more detail. \n\
3288 \n\
3289  Redacted form: plsyax(digmax, digits)\n\
3290 \n\
3291  This function is used in examples 1,14,31. \n\
3292 \n\
3293 \n\
3294 \n\
3295 SYNOPSIS:\n\
3296 \n\
3297 plsyax(digmax, digits)\n\
3298 \n\
3299 ARGUMENTS:\n\
3300 \n\
3301  digmax (PLINT, input) : Variable to set the maximum number of\n\
3302  digits for the y axis. If nonzero, the printed label will be\n\
3303  switched to a floating point representation when the number of\n\
3304  digits exceeds digmax. \n\
3305 \n\
3306  digits (PLINT, input) : Field digits value. Currently, changing\n\
3307  its value here has no effect since it is set only by plbox or\n\
3308  plbox3. However, the user may obtain its value after a call to\n\
3309  either of these functions by calling plgyax. \n\
3310 ";
3311 const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3312 Returns 8-bit RGB values for given color index from cmap0 \n\
3313 \n\
3314 DESCRIPTION:\n\
3315 \n\
3316  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3317  PLplot documentation). Values are negative if an invalid color id is\n\
3318  given. \n\
3319 \n\
3320  Redacted form: plgcol0(icol0, r, g, b)\n\
3321 \n\
3322  This function is used in example 2. \n\
3323 \n\
3324 \n\
3325 \n\
3326 SYNOPSIS:\n\
3327 \n\
3328 plgcol0(icol0, r, g, b)\n\
3329 \n\
3330 ARGUMENTS:\n\
3331 \n\
3332  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3333 \n\
3334  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3335 \n\
3336  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3337 \n\
3338  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3339 ";
3340 const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3341 Set seed for internal random number generator. \n\
3342 \n\
3343 DESCRIPTION:\n\
3344 \n\
3345  Set the seed for the internal random number generator. See plrandd for\n\
3346  further details. \n\
3347 \n\
3348  Redacted form: plseed(seed)\n\
3349 \n\
3350  This function is used in example 21. \n\
3351 \n\
3352 \n\
3353 \n\
3354 SYNOPSIS:\n\
3355 \n\
3356 plseed(seed)\n\
3357 \n\
3358 ARGUMENTS:\n\
3359 \n\
3360  seed (unsigned int, input) : Seed for random number generator. \n\
3361 ";
3362 const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3363 Magnitude colored plot surface with contour for z[x][y] with y index limits \n\
3364 \n\
3365 DESCRIPTION:\n\
3366 \n\
3367  When the implementation is completed this variant of plot3dc (see that\n\
3368  function\'s documentation for more details) should be suitable for the\n\
3369  case where the area of the x, y coordinate grid where z is defined can\n\
3370  be non-rectangular. The implementation is incomplete so the last 4\n\
3371  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3372  indexymax; are currently ignored and the functionality is otherwise\n\
3373  identical to that of plot3dc. \n\
3374 \n\
3375  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3376  indexymin, indexymax) \n\
3377 \t Perl/PDL: Not available? \n\
3378 \n\
3379 \n\
3380  This function is not used in any example. \n\
3381 \n\
3382 \n\
3383 \n\
3384 SYNOPSIS:\n\
3385 \n\
3386 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3387 \n\
3388 ARGUMENTS:\n\
3389 \n\
3390  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
3391  which the function is evaluated. \n\
3392 \n\
3393  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
3394  which the function is evaluated. \n\
3395 \n\
3396  z (const PLFLT * const *, input) : Pointer to a vectored\n\
3397  two-dimensional array with set of function values. \n\
3398 \n\
3399  nx (PLINT, input) : Number of x values at which the function is\n\
3400  evaluated. \n\
3401 \n\
3402  ny (PLINT, input) : Number of y values at which the function is\n\
3403  evaluated. \n\
3404 \n\
3405  opt (PLINT, input) : Determines the way in which the surface is\n\
3406  represented. To specify more than one option just add the options,\n\
3407  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3408  showing z as a function of x for each value of y[j] . \n\
3409  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3410  for each value of x[i] . \n\
3411  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3412  at which function is defined. \n\
3413  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3414  the z value being plotted. The color is used from the current\n\
3415  color map 1. \n\
3416  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3417  using parameters \n\
3418  nlevel and \n\
3419  clevel. \n\
3420  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3421  the borders of the plotted function. \n\
3422 \n\
3423 \n\
3424  clevel (const PLFLT *, input) : Pointer to the array that defines\n\
3425  the contour level spacing. \n\
3426 \n\
3427  nlevel (PLINT, input) : Number of elements in the clevel array. \n\
3428 \n\
3429  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3430  corresponds to the first x index where z is defined. \n\
3431 \n\
3432  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3433  which corresponds (by convention) to one more than the last x\n\
3434  index value where z is defined. \n\
3435 \n\
3436  indexymin (const PLINT *, input) : Array of y index values which\n\
3437  all must be ≥ 0. These values are the first y index where z is\n\
3438  defined for a particular x index in the range from indexxmin to\n\
3439  indexxmax - 1. The dimension of indexymin is indexxmax. \n\
3440 \n\
3441  indexymax (const PLINT *, input) : Array of y index values which\n\
3442  all must be ≤ ny. These values correspond (by convention) to one\n\
3443  more than the last y index where z is defined for a particular x\n\
3444  index in the range from indexxmin to indexxmax - 1. The dimension\n\
3445  of indexymax is indexxmax. \n\
3446 ";
3447 const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3448 Get output file name \n\
3449 \n\
3450 DESCRIPTION:\n\
3451 \n\
3452  Gets the current output file name, if applicable. \n\
3453 \n\
3454  Redacted form: plgfnam(fnam)\n\
3455 \n\
3456  This function is used in example 31. \n\
3457 \n\
3458 \n\
3459 \n\
3460 SYNOPSIS:\n\
3461 \n\
3462 plgfnam(fnam)\n\
3463 \n\
3464 ARGUMENTS:\n\
3465 \n\
3466  fnam (char *, output) : Pointer to file name string (a preallocated\n\
3467  string of 80 characters or more). \n\
3468 ";
3469 const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3470 Specify world coordinates of viewport boundaries \n\
3471 \n\
3472 DESCRIPTION:\n\
3473 \n\
3474  Sets up the world coordinates of the edges of the viewport. \n\
3475 \n\
3476  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3477 \n\
3478  This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3479 \n\
3480 \n\
3481 \n\
3482 SYNOPSIS:\n\
3483 \n\
3484 plwind(xmin, xmax, ymin, ymax)\n\
3485 \n\
3486 ARGUMENTS:\n\
3487 \n\
3488  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3489  of the viewport. \n\
3490 \n\
3491  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3492  of the viewport. \n\
3493 \n\
3494  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3495  the viewport. \n\
3496 \n\
3497  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3498  viewport. \n\
3499 ";
3500 const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3501 Set cmap1 colors using a piece-wise linear relationship \n\
3502 \n\
3503 DESCRIPTION:\n\
3504 \n\
3505  Set cmap1 colors using a piece-wise linear relationship between\n\
3506  intensity index (from 0. to 1.) of cmap1 and position in HLS or RGB\n\
3507  color space (see the PLplot documentation). May be called at any\n\
3508  time. \n\
3509 \n\
3510  The idea here is to specify a number of control points that define the\n\
3511  mapping between input cmap1 intensity indices and HLS (or RGB). \n\
3512  Between these points, linear interpolation is used which gives a\n\
3513  smooth variation of color with intensity index. Any number of control\n\
3514  points may be specified, located at arbitrary positions, although\n\
3515  typically 2 - 4 are enough. Another way of stating this is that we are\n\
3516  traversing a given number of lines through HLS (or RGB) space as we\n\
3517  move through cmap1 intensity indices. The control points at the\n\
3518  minimum and maximum position (0 and 1) must always be specified. By\n\
3519  adding more control points you can get more variation. One good\n\
3520  technique for plotting functions that vary about some expected average\n\
3521  is to use an additional 2 control points in the center (position ~=\n\
3522  0.5) that are the same lightness as the background (typically white\n\
3523  for paper output, black for crt), and same hue as the boundary control\n\
3524  points. This allows the highs and lows to be very easily\n\
3525  distinguished. \n\
3526 \n\
3527  Each control point must specify the cmap1 intensity index and the\n\
3528  associated three coordinates in HLS or RGB space. The first point\n\
3529  must correspond to position = 0, and the last to position = 1. \n\
3530 \n\
3531  The default behaviour is for the hue to be linearly interpolated\n\
3532  between the control points. Since the hue lies in the range [0, 360]\n\
3533  this corresponds to interpolation around the \"front\" of the color\n\
3534  wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3535  alternative interpolation is used between control points i and i+1. If\n\
3536  hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n\
3537  - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n\
3538  this as interpolation around the \"back\" or \"reverse\" of the color\n\
3539  wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3540  alt_hue_path[] = false for every control point. \n\
3541 \n\
3542  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3543  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3544  240]truegreen-yellow-red-magenta-blue[240\n\
3545  120]trueblue-magenta-red-yellow-green\n\
3546 \n\
3547  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3548  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3549  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3550 \n\
3551  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3552  alt_hue_path)\n\
3553 \n\
3554  This function is used in examples 8,11,12,15,20,21. \n\
3555 \n\
3556 \n\
3557 \n\
3558 SYNOPSIS:\n\
3559 \n\
3560 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3561 \n\
3562 ARGUMENTS:\n\
3563 \n\
3564  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3565 \n\
3566  npts (PLINT, input) : number of control points \n\
3567 \n\
3568  intensity (const PLFLT *, input) : intensity index for each control\n\
3569  point (between 0.0 and 1.0, in ascending order) \n\
3570 \n\
3571  coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n\
3572  control point \n\
3573 \n\
3574  coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n\
3575  control point \n\
3576 \n\
3577  coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n\
3578  control point \n\
3579 \n\
3580  alt_hue_path (const PLBOOL *, input) : alternative interpolation\n\
3581  method flag for each control point. (alt_hue_path[i] refers to the\n\
3582  interpolation interval between the i and i + 1 control points). \n\
3583 ";
3584 const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3585 Set the pause (on end-of-page) status \n\
3586 \n\
3587 DESCRIPTION:\n\
3588 \n\
3589  Set the pause (on end-of-page) status. \n\
3590 \n\
3591  Redacted form: plspause(pause)\n\
3592 \n\
3593  This function is in examples 14,20. \n\
3594 \n\
3595 \n\
3596 \n\
3597 SYNOPSIS:\n\
3598 \n\
3599 plspause(pause)\n\
3600 \n\
3601 ARGUMENTS:\n\
3602 \n\
3603  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3604  end-of-page for those drivers which support this. Otherwise there\n\
3605  is no pause. \n\
3606 ";
3607 const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
3608 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3609 \n\
3610 DESCRIPTION:\n\
3611 \n\
3612  Routine for creating a discrete plot legend with a plotted filled box,\n\
3613  line, and/or line of symbols for each annotated legend entry. (See\n\
3614  plcolorbar for similar functionality for creating continuous color\n\
3615  bars.) The arguments of pllegend provide control over the location\n\
3616  and size of the legend as well as the location and characteristics of\n\
3617  the elements (most of which are optional) within that legend. The\n\
3618  resulting legend is clipped at the boundaries of the current subpage. \n\
3619  (N.B. the adopted coordinate system used for some of the parameters is\n\
3620  defined in the documentation of the position parameter.) \n\
3621 \n\
3622  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3623  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3624  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3625  test_justification, text_colors, text, box_colors, box_patterns,\n\
3626  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3627  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3628 \n\
3629  This function is used in examples 4, 26, and 33. \n\
3630 \n\
3631 \n\
3632 \n\
3633 SYNOPSIS:\n\
3634 \n\
3635 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\
3636 \n\
3637 ARGUMENTS:\n\
3638 \n\
3639  p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3640  contains (after the call) the legend width in adopted coordinates.\n\
3641  This quantity is calculated from plot_width, text_offset, ncolumn\n\
3642  (possibly modified inside the routine depending on nlegend and\n\
3643  nrow), and the length (calculated internally) of the longest text\n\
3644  string. \n\
3645 \n\
3646  p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3647  contains (after the call) the legend height in adopted\n\
3648  coordinates. This quantity is calculated from text_scale,\n\
3649  text_spacing, and nrow (possibly modified inside the routine\n\
3650  depending on nlegend and nrow). \n\
3651 \n\
3652  opt (PLINT, input) : opt contains bits controlling the overall\n\
3653  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3654  on the left of the legend and the plotted area on the right.\n\
3655  Otherwise, put the text area on the right of the legend and the\n\
3656  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3657  plot a (semi-transparent) background for the legend. If the\n\
3658  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3659  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3660  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3661  plot the resulting array of legend entries in row-major order.\n\
3662  Otherwise, plot the legend entries in column-major order. \n\
3663 \n\
3664  position (PLINT, input) : position contains bits which control the\n\
3665  overall position of the legend and the definition of the adopted\n\
3666  coordinates used for positions just like what is done for the\n\
3667  position argument for plcolorbar. However, note that the defaults\n\
3668  for the position bits (see below) are different than the\n\
3669  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3670  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3671  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3672  the 16 possible standard positions (the 4 corners and centers of\n\
3673  the 4 sides for both the inside and outside cases) of the legend\n\
3674  relative to the adopted coordinate system. The corner positions\n\
3675  are specified by the appropriate combination of two of the\n\
3676  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3677  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3678  value of one of those bits. The adopted coordinates are\n\
3679  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3680  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3681  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3682  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3683  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3684  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3685  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3686  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3687 \n\
3688  x (PLFLT, input) : X offset of the legend position in adopted\n\
3689  coordinates from the specified standard position of the legend.\n\
3690  For positive x, the direction of motion away from the standard\n\
3691  position is inward/outward from the standard corner positions or\n\
3692  standard left or right positions if the\n\
3693  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3694  For the standard top or bottom positions, the direction of motion\n\
3695  is toward positive X. \n\
3696 \n\
3697  y (PLFLT, input) : Y offset of the legend position in adopted\n\
3698  coordinates from the specified standard position of the legend.\n\
3699  For positive y, the direction of motion away from the standard\n\
3700  position is inward/outward from the standard corner positions or\n\
3701  standard top or bottom positions if the\n\
3702  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3703  For the standard left or right positions, the direction of motion\n\
3704  is toward positive Y. \n\
3705 \n\
3706  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3707  of the plot area (where the colored boxes, lines, and/or lines of\n\
3708  symbols are drawn) of the legend. \n\
3709 \n\
3710  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3711  legend (PL_LEGEND_BACKGROUND). \n\
3712 \n\
3713  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3714  for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3715 \n\
3716  bb_style (PLINT, input) : The pllsty style number for the\n\
3717  bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n\
3718 \n\
3719  nrow (PLINT, input) : The cmap0 index of the background color for\n\
3720  the legend (PL_LEGEND_BACKGROUND). \n\
3721 \n\
3722  ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3723  for the legend (PL_LEGEND_BACKGROUND). \n\
3724 \n\
3725  nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3726  vertical height of the legend in adopted coordinates is calculated\n\
3727  internally from nlegend, text_scale (see below), and text_spacing\n\
3728  (see below). \n\
3729 \n\
3730  opt_array (const PLINT *, input) : Array of nlegend values of\n\
3731  options to control each individual plotted area corresponding to a\n\
3732  legend entry. If the \n\
3733  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3734  area. If the \n\
3735  PL_LEGEND_COLOR_BOX, \n\
3736  PL_LEGEND_LINE, and/or \n\
3737  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3738  entry is plotted with a colored box; a line; and/or a line of\n\
3739  symbols. \n\
3740 \n\
3741  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3742  area in units of character width. N.B. The total horizontal\n\
3743  width of the legend in adopted coordinates is calculated\n\
3744  internally from \n\
3745  plot_width (see above), \n\
3746  text_offset, and length (calculated internally) of the longest text\n\
3747  string. \n\
3748 \n\
3749  text_scale (PLFLT, input) : Character height scale for text\n\
3750  annotations. N.B. The total vertical height of the legend in\n\
3751  adopted coordinates is calculated internally from \n\
3752  nlegend (see above), \n\
3753  text_scale, and \n\
3754  text_spacing (see below). \n\
3755 \n\
3756  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3757  character height from one legend entry to the next. N.B. The\n\
3758  total vertical height of the legend in adopted coordinates is\n\
3759  calculated internally from \n\
3760  nlegend (see above), \n\
3761  text_scale (see above), and \n\
3762  text_spacing. \n\
3763 \n\
3764  text_justification (PLFLT, input) : Justification parameter used\n\
3765  for text justification. The most common values of\n\
3766  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3767  is left justified, centred, or right justified within the text\n\
3768  area, but other values are allowed as well. \n\
3769 \n\
3770  text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n\
3771  colors. \n\
3772 \n\
3773  text (const char * const *, input) : Array of nlegend text string\n\
3774  annotations. \n\
3775 \n\
3776  box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n\
3777  for the discrete colored boxes (\n\
3778  PL_LEGEND_COLOR_BOX). \n\
3779 \n\
3780  box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3781  (plpsty indices) for the discrete colored boxes (\n\
3782  PL_LEGEND_COLOR_BOX). \n\
3783 \n\
3784  box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3785  of fraction of character height) for the height of the discrete\n\
3786  colored boxes (\n\
3787  PL_LEGEND_COLOR_BOX). \n\
3788 \n\
3789  box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3790  widths for the patterns specified by box_patterns (\n\
3791  PL_LEGEND_COLOR_BOX). \n\
3792 \n\
3793  line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n\
3794  colors (\n\
3795  PL_LEGEND_LINE). \n\
3796 \n\
3797  line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3798  (plsty indices) (\n\
3799  PL_LEGEND_LINE). \n\
3800 \n\
3801  line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3802  PL_LEGEND_LINE). \n\
3803 \n\
3804  symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n\
3805  symbol colors (\n\
3806  PL_LEGEND_SYMBOL). \n\
3807 \n\
3808  symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3809  values for the symbol height (\n\
3810  PL_LEGEND_SYMBOL). \n\
3811 \n\
3812  symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3813  symbols to be drawn across the width of the plotted area (\n\
3814  PL_LEGEND_SYMBOL). \n\
3815 \n\
3816  symbols (const char * const *, input) : Array of nlegend symbols\n\
3817  (plpoin indices) (\n\
3818  PL_LEGEND_SYMBOL). \n\
3819 ";
3820 const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
3821 Set number of colors in cmap1 \n\
3822 \n\
3823 DESCRIPTION:\n\
3824 \n\
3825  Set number of colors in cmap1, (re-)allocate color map1, and set\n\
3826  default values if this is the first allocation (see the PLplot\n\
3827  documentation). \n\
3828 \n\
3829  Redacted form: plscmap1n(ncol1)\n\
3830 \n\
3831  This function is used in examples 8,11,20,21. \n\
3832 \n\
3833 \n\
3834 \n\
3835 SYNOPSIS:\n\
3836 \n\
3837 plscmap1n(ncol1)\n\
3838 \n\
3839 ARGUMENTS:\n\
3840 \n\
3841  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3842  the map1 palette. If this number is zero or less, then the value\n\
3843  from the previous call to plscmap1n is used and if there is no\n\
3844  previous call, then a default value is used. \n\
3845 ";
3846 const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
3847 Returns 8-bit RGB values and double alpha transparency value for given color index from cmap0 \n\
3848 \n\
3849 DESCRIPTION:\n\
3850 \n\
3851  Returns 8-bit RGB values (0-255) and double alpha transparency value\n\
3852  (0.0 - 1.0) for given color from cmap0 (see the PLplot\n\
3853  documentation). Values are negative if an invalid color id is given. \n\
3854 \n\
3855  This function is used in example 30. \n\
3856 \n\
3857 \n\
3858 \n\
3859 SYNOPSIS:\n\
3860 \n\
3861 plgcol0a(icol0, r, g, b, alpha)\n\
3862 \n\
3863 ARGUMENTS:\n\
3864 \n\
3865  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3866 \n\
3867  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3868 \n\
3869  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3870 \n\
3871  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3872 \n\
3873  alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
3874  value. \n\
3875 ";
3876 const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
3877 Replays contents of plot buffer to current device/file \n\
3878 \n\
3879 DESCRIPTION:\n\
3880 \n\
3881  Replays contents of plot buffer to current device/file. \n\
3882 \n\
3883  Redacted form: plreplot()\n\
3884 \n\
3885  This function is used in example 1,20. \n\
3886 \n\
3887 \n\
3888 \n\
3889 SYNOPSIS:\n\
3890 \n\
3891 plreplot()\n\
3892 ";
3893 const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
3894 Simple routine to write labels \n\
3895 \n\
3896 DESCRIPTION:\n\
3897 \n\
3898  Routine for writing simple labels. Use plmtex for more complex labels. \n\
3899 \n\
3900  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3901 \n\
3902  This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3903 \n\
3904 \n\
3905 \n\
3906 SYNOPSIS:\n\
3907 \n\
3908 pllab(xlabel, ylabel, tlabel)\n\
3909 \n\
3910 ARGUMENTS:\n\
3911 \n\
3912  xlabel (const char *, input) : Label for horizontal axis. \n\
3913 \n\
3914  ylabel (const char *, input) : Label for vertical axis. \n\
3915 \n\
3916  tlabel (const char *, input) : Title of graph. \n\
3917 ";
3918 const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
3919 Set parameters that define current device-space window \n\
3920 \n\
3921 DESCRIPTION:\n\
3922 \n\
3923  Set relative margin width, aspect ratio, and relative justification\n\
3924  that define current device-space window. If you want to just use the\n\
3925  previous value for any of these, just pass in the magic value\n\
3926  PL_NOTSET. It is unlikely that one should ever need to change the\n\
3927  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3928  called the default values of mar, jx, and jy are all 0. aspect is set\n\
3929  to a device-specific value. \n\
3930 \n\
3931  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3932 \n\
3933  This function is used in example 31. \n\
3934 \n\
3935 \n\
3936 \n\
3937 SYNOPSIS:\n\
3938 \n\
3939 plsdidev(mar, aspect, jx, jy)\n\
3940 \n\
3941 ARGUMENTS:\n\
3942 \n\
3943  mar (PLFLT, input) : Relative margin width. \n\
3944 \n\
3945  aspect (PLFLT, input) : Aspect ratio. \n\
3946 \n\
3947  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3948  the range -0.5 to 0.5. \n\
3949 \n\
3950  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3951  the range -0.5 to 0.5. \n\
3952 ";
3953 const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
3954 Begin a new page\n\
3955 \n\
3956 DESCRIPTION:\n\
3957 \n\
3958  Begins a new page.\tFor a file driver, the output file is opened if\n\
3959  necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3960  page break is desired at a particular point when plotting to subpages.\n\
3961  Another use for pleop and plbop is when plotting pages to different\n\
3962  files, since you can manually set the file name by calling plsfnam\n\
3963  after the call to pleop. (In fact some drivers may only support a\n\
3964  single page per file, making this a necessity.) One way to handle\n\
3965  this case automatically is to page advance via pladv, but enable\n\
3966  familying (see plsfam) with a small limit on the file size so that a\n\
3967  new family member file will be created on each page break. \n\
3968 \n\
3969  Redacted form: plbop()\n\
3970 \n\
3971  This function is used in examples 2,20. \n\
3972 \n\
3973 \n\
3974 \n\
3975 SYNOPSIS:\n\
3976 \n\
3977 plbop()\n\
3978 ";
3979 const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
3980 Set cmap0 colors by 8-bit RGB values \n\
3981 \n\
3982 DESCRIPTION:\n\
3983 \n\
3984  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
3985  documentation). This sets the entire color map -- only as many colors\n\
3986  as specified will be allocated. \n\
3987 \n\
3988  Redacted form: plscmap0(r, g, b)\n\
3989 \n\
3990  This function is used in examples 2,24. \n\
3991 \n\
3992 \n\
3993 \n\
3994 SYNOPSIS:\n\
3995 \n\
3996 plscmap0(r, g, b, ncol0)\n\
3997 \n\
3998 ARGUMENTS:\n\
3999 \n\
4000  r (const PLINT *, input) : Pointer to array with set of unsigned\n\
4001  8-bit integers (0-255) representing the degree of red in the\n\
4002  color. \n\
4003 \n\
4004  g (const PLINT *, input) : Pointer to array with set of unsigned\n\
4005  8-bit integers (0-255) representing the degree of green in the\n\
4006  color. \n\
4007 \n\
4008  b (const PLINT *, input) : Pointer to array with set of unsigned\n\
4009  8-bit integers (0-255) representing the degree of blue in the\n\
4010  color. \n\
4011 \n\
4012  ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
4013 ";
4014 const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4015 Set the number of subpages in x and y \n\
4016 \n\
4017 DESCRIPTION:\n\
4018 \n\
4019  Set the number of subpages in x and y. \n\
4020 \n\
4021  Redacted form: plssub(nx, ny)\n\
4022 \n\
4023  This function is examples 1,2,14,21,25,27. \n\
4024 \n\
4025 \n\
4026 \n\
4027 SYNOPSIS:\n\
4028 \n\
4029 plssub(nx, ny)\n\
4030 \n\
4031 ARGUMENTS:\n\
4032 \n\
4033  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4034  of window columns). \n\
4035 \n\
4036  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4037  of window rows). \n\
4038 ";
4039 const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4040 Set a global coordinate transform function \n\
4041 \n\
4042 DESCRIPTION:\n\
4043 \n\
4044  This function can be used to define a coordinate transformation which\n\
4045  affects all elements drawn within the current plot window. The\n\
4046  coordinate_transform function is similar to that provided for the\n\
4047  plmap and plmeridians functions. The coordinate_transform_data\n\
4048  parameter may be used to pass extra data to coordinate_transform. \n\
4049 \n\
4050  Redacted form: General: plstransform(coordinate_transform,\n\
4051  coordinate_transform_data)\n\
4052 \n\
4053 \n\
4054  This function is used in examples 19 and 22. \n\
4055 \n\
4056 \n\
4057 \n\
4058 SYNOPSIS:\n\
4059 \n\
4060 plstransform(coordinate_transform, coordinate_transform_data)\n\
4061 \n\
4062 ARGUMENTS:\n\
4063 \n\
4064  coordinate_transform (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *,\n\
4065  PLPointer) , input) : Pointer to a function that defines a\n\
4066  transformation from the input (x, y) coordinate to a new plot\n\
4067  world coordinate. A NULL pointer means that no transform is\n\
4068  applied. \n\
4069 \n\
4070  coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4071  for \n\
4072  coordinate_transform. \n\
4073 ";
4074 const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4075 Set cmap1 colors using 8-bit RGB values \n\
4076 \n\
4077 DESCRIPTION:\n\
4078 \n\
4079  Set cmap1 colors using 8-bit RGB values (see the PLplot\n\
4080  documentation). This also sets the number of colors. \n\
4081 \n\
4082  Redacted form: plscmap1(r, g, b)\n\
4083 \n\
4084  This function is used in example 31. \n\
4085 \n\
4086 \n\
4087 \n\
4088 SYNOPSIS:\n\
4089 \n\
4090 plscmap1(r, g, b, ncol1)\n\
4091 \n\
4092 ARGUMENTS:\n\
4093 \n\
4094  r (const PLINT *, input) : Pointer to array with set of unsigned\n\
4095  8-bit integers (0-255) representing the degree of red in the\n\
4096  color. \n\
4097 \n\
4098  g (const PLINT *, input) : Pointer to array with set of unsigned\n\
4099  8-bit integers (0-255) representing the degree of green in the\n\
4100  color. \n\
4101 \n\
4102  b (const PLINT *, input) : Pointer to array with set of unsigned\n\
4103  8-bit integers (0-255) representing the degree of blue in the\n\
4104  color. \n\
4105 \n\
4106  ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
4107 ";
4108 const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4109 Configure the transformation between continuous and broken-down time for the current stream \n\
4110 \n\
4111 DESCRIPTION:\n\
4112 \n\
4113  Configure the transformation between continuous and broken-down time\n\
4114  for the current stream. This transformation is used by both plbtime\n\
4115  and plctime. \n\
4116 \n\
4117  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4118  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4119 \t Perl/PDL: Not available? \n\
4120 \n\
4121 \n\
4122  This function is used in example 29. \n\
4123 \n\
4124 \n\
4125 \n\
4126 SYNOPSIS:\n\
4127 \n\
4128 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4129 \n\
4130 ARGUMENTS:\n\
4131 \n\
4132  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4133  As a special case, if \n\
4134  scale is 0., then all other arguments are ignored, and the result (the\n\
4135  default used by PLplot) is the equivalent of a call to\n\
4136  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4137  That is, for this special case broken-down time is calculated with\n\
4138  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4139  and the continuous time is defined as the number of seconds since\n\
4140  the Unix epoch of 1970-01-01T00:00:00Z. \n\
4141 \n\
4142  offset1 (PLFLT, input) : If \n\
4143  ifbtime_offset is true, the parameters \n\
4144  offset1 and \n\
4145  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4146  (with units in days) specify the epoch of the continuous time\n\
4147  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4148  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4149  are used to specify the origin to allow users (by specifying \n\
4150  offset1 as an integer that can be exactly represented by a\n\
4151  floating-point variable and specifying \n\
4152  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4153  the numerical errors of the continuous time representation. \n\
4154 \n\
4155  offset2 (PLFLT, input) : See documentation of \n\
4156  offset1. \n\
4157 \n\
4158  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4159  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4160  calendar is used for broken-down time rather than the proleptic\n\
4161  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4162  have been historically used to define UTC are inserted into the\n\
4163  broken-down time. Other possibilities for additional control bits\n\
4164  for ccontrol exist such as making the historical time corrections\n\
4165  in the broken-down time corresponding to ET (ephemeris time) or\n\
4166  making the (slightly non-constant) corrections from international\n\
4167  atomic time (TAI) to what astronomers define as terrestrial time\n\
4168  (TT). But those additional possibilities have not been\n\
4169  implemented yet in the qsastime library (one of the PLplot utility\n\
4170  libraries). \n\
4171 \n\
4172  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4173  epoch of the continuous time scale is specified by the user. If \n\
4174  ifbtime_offset is false, then \n\
4175  offset1 and \n\
4176  offset2 are used to specify the epoch, and the following broken-down\n\
4177  time parameters are completely ignored. If \n\
4178  ifbtime_offset is true, then \n\
4179  offset1 and \n\
4180  offset2 are completely ignored, and the following broken-down time\n\
4181  parameters are used to specify the epoch. \n\
4182 \n\
4183  year (PLINT, input) : Year of epoch. \n\
4184 \n\
4185  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4186  11 (December). \n\
4187 \n\
4188  day (PLINT, input) : Day of epoch in range from 1 to 31. \n\
4189 \n\
4190  hour (PLINT, input) : Hour of epoch in range from 0 to 23 \n\
4191 \n\
4192  min (PLINT, input) : Minute of epoch in range from 0 to 59. \n\
4193 \n\
4194  sec (PLFLT, input) : Second of epoch in floating range from 0. to\n\
4195  60. \n\
4196 ";
4197 const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4198 Set length of minor ticks \n\
4199 \n\
4200 DESCRIPTION:\n\
4201 \n\
4202  This sets up the length of the minor ticks and the length of the\n\
4203  terminals on error bars. The actual length is the product of the\n\
4204  default length and a scaling factor as for character height. \n\
4205 \n\
4206  Redacted form: plsmin(def, scale)\n\
4207 \n\
4208  This function is used in example 29. \n\
4209 \n\
4210 \n\
4211 \n\
4212 SYNOPSIS:\n\
4213 \n\
4214 plsmin(def, scale)\n\
4215 \n\
4216 ARGUMENTS:\n\
4217 \n\
4218  def (PLFLT, input) : The default length of a minor tick in\n\
4219  millimeters, should be set to zero if the default length is to\n\
4220  remain unchanged. \n\
4221 \n\
4222  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4223  actual tick length. \n\
4224 ";
4225 const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4226 Set character size \n\
4227 \n\
4228 DESCRIPTION:\n\
4229 \n\
4230  This sets up the size of all subsequent characters drawn. The actual\n\
4231  height of a character is the product of the default character size and\n\
4232  a scaling factor. \n\
4233 \n\
4234  Redacted form: plschr(def, scale)\n\
4235 \n\
4236  This function is used in example 2,13,23,24. \n\
4237 \n\
4238 \n\
4239 \n\
4240 SYNOPSIS:\n\
4241 \n\
4242 plschr(def, scale)\n\
4243 \n\
4244 ARGUMENTS:\n\
4245 \n\
4246  def (PLFLT, input) : The default height of a character in\n\
4247  millimeters, should be set to zero if the default height is to\n\
4248  remain unchanged. \n\
4249 \n\
4250  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4251  actual character height. \n\
4252 ";
4253 const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4254 Initialize PLplot \n\
4255 \n\
4256 DESCRIPTION:\n\
4257 \n\
4258  Initializing the plotting package.\tThe program prompts for the device\n\
4259  keyword or number of the desired output device. Hitting a RETURN in\n\
4260  response to the prompt is the same as selecting the first device. \n\
4261  plinit will issue no prompt if either the device was specified\n\
4262  previously (via command line flag, the plsetopt function, or the\n\
4263  plsdev function), or if only one device is enabled when PLplot is\n\
4264  installed.\tIf subpages have been specified, the output device is\n\
4265  divided into nx by ny subpages, each of which may be used\n\
4266  independently. If plinit is called again during a program, the\n\
4267  previously opened file will be closed. The subroutine pladv is used\n\
4268  to advance from one subpage to the next. \n\
4269 \n\
4270  Redacted form: plinit()\n\
4271 \n\
4272  This function is used in all of the examples. \n\
4273 \n\
4274 \n\
4275 \n\
4276 SYNOPSIS:\n\
4277 \n\
4278 plinit()\n\
4279 ";
4280 const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4281 Draw a box with axes, etc\n\
4282 \n\
4283 DESCRIPTION:\n\
4284 \n\
4285  Draws a box around the currently defined viewport, and labels it with\n\
4286  world coordinate values appropriate to the window.\tThus plbox should\n\
4287  only be called after defining both viewport and window. The character\n\
4288  strings xopt and yopt specify how the box should be drawn as described\n\
4289  below. If ticks and/or subticks are to be drawn for a particular\n\
4290  axis, the tick intervals and number of subintervals may be specified\n\
4291  explicitly, or they may be defaulted by setting the appropriate\n\
4292  arguments to zero. \n\
4293 \n\
4294  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4295 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4296 \n\
4297 \n\
4298  This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4299 \n\
4300 \n\
4301 \n\
4302 SYNOPSIS:\n\
4303 \n\
4304 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4305 \n\
4306 ARGUMENTS:\n\
4307 \n\
4308  xopt (const char *, input) : Pointer to character string specifying\n\
4309  options for horizontal axis. The string can include any\n\
4310  combination of the following letters (upper or lower case) in any\n\
4311  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4312  is vertical line (x=0). \n\
4313  b: Draws bottom (X) or left (Y) edge of frame. \n\
4314  c: Draws top (X) or right (Y) edge of frame. \n\
4315  d: Plot labels as date / time. Values are assumed to be\n\
4316  seconds since the epoch (as used by gmtime). \n\
4317  f: Always use fixed point numeric labels. \n\
4318  g: Draws a grid at the major tick interval. \n\
4319  h: Draws a grid at the minor tick interval. \n\
4320  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4321  inwards. \n\
4322  l: Labels axis logarithmically. This only affects the labels,\n\
4323  not the data, and so it is necessary to compute the logarithms\n\
4324  of data points before passing them to any of the drawing\n\
4325  routines. \n\
4326  m: Writes numeric labels at major tick intervals in the\n\
4327  unconventional location (above box for X, right of box for Y). \n\
4328  n: Writes numeric labels at major tick intervals in the\n\
4329  conventional location (below box for X, left of box for Y). \n\
4330  o: Use custom labelling function to generate axis label text. \n\
4331  The custom labelling function can be defined with the\n\
4332  plslabelfunc command. \n\
4333  s: Enables subticks between major ticks, only valid if t is\n\
4334  also specified. \n\
4335  t: Draws major ticks. \n\
4336  u: Exactly like \"b\" except don\'t draw edge line. \n\
4337  w: Exactly like \"c\" except don\'t draw edge line. \n\
4338  x: Exactly like \"t\" (including the side effect of the\n\
4339  numerical labels for the major ticks) except exclude drawing\n\
4340  the major and minor tick marks. \n\
4341 \n\
4342 \n\
4343  xtick (PLFLT, input) : World coordinate interval between major\n\
4344  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4345  generates a suitable tick interval. \n\
4346 \n\
4347  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4348  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4349  generates a suitable minor tick interval. \n\
4350 \n\
4351  yopt (const char *, input) : Pointer to character string specifying\n\
4352  options for vertical axis. The string can include any combination\n\
4353  of the letters defined above for xopt, and in addition may\n\
4354  contain: v: Write numeric labels for vertical axis parallel to the\n\
4355  base of the graph, rather than parallel to the axis. \n\
4356 \n\
4357 \n\
4358  ytick (PLFLT, input) : World coordinate interval between major\n\
4359  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4360  generates a suitable tick interval. \n\
4361 \n\
4362  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4363  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4364  generates a suitable minor tick interval. \n\
4365 ";
4366 const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4367 Get parameters that define current device-space window \n\
4368 \n\
4369 DESCRIPTION:\n\
4370 \n\
4371  Get relative margin width, aspect ratio, and relative justification\n\
4372  that define current device-space window. If plsdidev has not been\n\
4373  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4374  p_jy will all be 0. \n\
4375 \n\
4376  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4377 \n\
4378  This function is used in example 31. \n\
4379 \n\
4380 \n\
4381 \n\
4382 SYNOPSIS:\n\
4383 \n\
4384 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4385 \n\
4386 ARGUMENTS:\n\
4387 \n\
4388  p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4389 \n\
4390  p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4391 \n\
4392  p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4393 \n\
4394  p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4395 ";
4396 const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4397 Plot a glyph at the specified points \n\
4398 \n\
4399 DESCRIPTION:\n\
4400 \n\
4401  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4402  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4403  is specified with a PLplot user string. Note that the user string is\n\
4404  not actually limited to one glyph so it is possible (but not normally\n\
4405  useful) to plot more than one glyph at the specified points with this\n\
4406  function. As with plmtex and plptex, the user string can contain FCI\n\
4407  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4408  else PLplot escapes for Hershey or unicode text to determine the\n\
4409  glyph. \n\
4410 \n\
4411  Redacted form: plstring(x, y, string)\n\
4412 \n\
4413  This function is used in examples 4, 21 and 26. \n\
4414 \n\
4415 \n\
4416 \n\
4417 SYNOPSIS:\n\
4418 \n\
4419 plstring(n, x, y, string)\n\
4420 \n\
4421 ARGUMENTS:\n\
4422 \n\
4423  n (PLINT, input) : Number of points in the x and y arrays. \n\
4424 \n\
4425  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
4426  of points. \n\
4427 \n\
4428  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
4429  of points. \n\
4430 \n\
4431  string (const char *, input) : PLplot user string corresponding to\n\
4432  the glyph to be plotted at each of the n points. \n\
4433 ";
4434 const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4435 Plot all or a subset of Shapefile data using strings or points in world coordinates \n\
4436 \n\
4437 DESCRIPTION:\n\
4438 \n\
4439  As per plmapline, however the items are plotted as strings or points\n\
4440  in the same way as plstring. \n\
4441 \n\
4442  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4443  maxy, plotentries)\n\
4444 \n\
4445  This function is used in example 19. \n\
4446 \n\
4447 \n\
4448 \n\
4449 SYNOPSIS:\n\
4450 \n\
4451 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4452 \n\
4453 ARGUMENTS:\n\
4454 \n\
4455  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
4456  supplied function to transform the coordinates given in the\n\
4457  shapefile into a plot coordinate system. By using this transform,\n\
4458  we can change from a longitude, latitude coordinate to a polar\n\
4459  stereographic project, for example. Initially, x[0]..[n-1] are\n\
4460  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
4461  After the call to mapform(), x[] and y[] should be replaced by the\n\
4462  corresponding plot coordinates. If no transform is desired,\n\
4463  mapform can be replaced by NULL. \n\
4464 \n\
4465  name (const char *, input) : The file name of a set of Shapefile\n\
4466  files without the file extension. \n\
4467 \n\
4468  string (const char *, input) : A NULL terminated string of\n\
4469  characters to be drawn. \n\
4470 \n\
4471  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4472  be in the same units as used by the Shapefile. You could use a\n\
4473  very large negative number to plot everything, but you can improve\n\
4474  performance by limiting the area drawn. The units must match those\n\
4475  of the Shapefile projection, which may be for example longitude or\n\
4476  distance. The value of minx must be less than the value of maxx. \n\
4477 \n\
4478  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4479  use a very large number to plot everything, but you can improve\n\
4480  performance by limiting the area drawn. \n\
4481 \n\
4482  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4483  be in the same units as used by the Shapefile. You could use a\n\
4484  very large negative number to plot everything, but you can improve\n\
4485  performance by limiting the area drawn. The units must match those\n\
4486  of the Shapefile projection, which may be for example latitude or\n\
4487  distance. The value of miny must be less than the value of maxy. \n\
4488 \n\
4489  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4490  use a very large number to plot everything, but you can improve\n\
4491  performance by limiting the area drawn. \n\
4492 \n\
4493  plotentries (const PLINT *, input) : An array of integers\n\
4494  indicating the elements of the Shapefile (zero indexed) which will\n\
4495  be drawn. Setting plotentries to NULL will plot all elements of\n\
4496  the Shapefile. \n\
4497 \n\
4498  nplotentries (PLINT, input) : The number of items in plotentries.\n\
4499  Ignored if plotentries is NULL. \n\
4500 ";
4501 const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4502 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it \n\
4503 \n\
4504 DESCRIPTION:\n\
4505 \n\
4506  Sets up plotter environment for simple graphs by calling pladv and\n\
4507  setting up viewport and window to sensible default values.\tplenv0\n\
4508  leaves enough room around most graphs for axis labels and a title.\n\
4509  When these defaults are not suitable, use the individual routines\n\
4510  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4511  defining the window, and plbox for drawing the box. \n\
4512 \n\
4513  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4514 \n\
4515  This function is used in example 21. \n\
4516 \n\
4517 \n\
4518 \n\
4519 SYNOPSIS:\n\
4520 \n\
4521 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4522 \n\
4523 ARGUMENTS:\n\
4524 \n\
4525  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4526  world coordinates). \n\
4527 \n\
4528  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4529  world coordinates). \n\
4530 \n\
4531  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4532  coordinates). \n\
4533 \n\
4534  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4535  coordinates). \n\
4536 \n\
4537  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4538  scales will not be set, the user must set up the scale before\n\
4539  calling plenv0 using plsvpa, plvasp or other. \n\
4540  0: the x and y axes are scaled independently to use as much of\n\
4541  the screen as possible. \n\
4542  1: the scales of the x and y axes are made equal. \n\
4543  2: the axis of the x and y axes are made equal, and the plot\n\
4544  box will be square. \n\
4545 \n\
4546 \n\
4547  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4548  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4549  -1: draw box only. \n\
4550  0: draw box, ticks, and numeric tick labels. \n\
4551  1: also draw coordinate axes at x=0 and y=0. \n\
4552  2: also draw a grid at major tick positions in both\n\
4553  coordinates. \n\
4554  3: also draw a grid at minor tick positions in both\n\
4555  coordinates. \n\
4556  10: same as 0 except logarithmic x tick marks. (The x data\n\
4557  have to be converted to logarithms separately.) \n\
4558  11: same as 1 except logarithmic x tick marks. (The x data\n\
4559  have to be converted to logarithms separately.) \n\
4560  12: same as 2 except logarithmic x tick marks. (The x data\n\
4561  have to be converted to logarithms separately.) \n\
4562  13: same as 3 except logarithmic x tick marks. (The x data\n\
4563  have to be converted to logarithms separately.) \n\
4564  20: same as 0 except logarithmic y tick marks. (The y data\n\
4565  have to be converted to logarithms separately.) \n\
4566  21: same as 1 except logarithmic y tick marks. (The y data\n\
4567  have to be converted to logarithms separately.) \n\
4568  22: same as 2 except logarithmic y tick marks. (The y data\n\
4569  have to be converted to logarithms separately.) \n\
4570  23: same as 3 except logarithmic y tick marks. (The y data\n\
4571  have to be converted to logarithms separately.) \n\
4572  30: same as 0 except logarithmic x and y tick marks. (The x\n\
4573  and y data have to be converted to logarithms separately.) \n\
4574  31: same as 1 except logarithmic x and y tick marks. (The x\n\
4575  and y data have to be converted to logarithms separately.) \n\
4576  32: same as 2 except logarithmic x and y tick marks. (The x\n\
4577  and y data have to be converted to logarithms separately.) \n\
4578  33: same as 3 except logarithmic x and y tick marks. (The x\n\
4579  and y data have to be converted to logarithms separately.) \n\
4580  40: same as 0 except date / time x labels. \n\
4581  41: same as 1 except date / time x labels. \n\
4582  42: same as 2 except date / time x labels. \n\
4583  43: same as 3 except date / time x labels. \n\
4584  50: same as 0 except date / time y labels. \n\
4585  51: same as 1 except date / time y labels. \n\
4586  52: same as 2 except date / time y labels. \n\
4587  53: same as 3 except date / time y labels. \n\
4588  60: same as 0 except date / time x and y labels. \n\
4589  61: same as 1 except date / time x and y labels. \n\
4590  62: same as 2 except date / time x and y labels. \n\
4591  63: same as 3 except date / time x and y labels. \n\
4592  70: same as 0 except custom x and y labels. \n\
4593  71: same as 1 except custom x and y labels. \n\
4594  72: same as 2 except custom x and y labels. \n\
4595  73: same as 3 except custom x and y labels. \n\
4596 ";
4597 const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
4598 Set up window for 3-d plotting \n\
4599 \n\
4600 DESCRIPTION:\n\
4601 \n\
4602  Sets up a window for a three-dimensional surface plot within the\n\
4603  currently defined two-dimensional window. The enclosing box for the\n\
4604  surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4605  user-coordinate space is mapped into a box of world coordinate size\n\
4606  basex by basey by height so that xmin maps to -\n\
4607  basex/2 , xmax maps to basex/2 , ymin maps to -\n\
4608  basey/2 , ymax maps to basey/2 , zmin maps to 0 and zmax maps to\n\
4609  height. The resulting world-coordinate box is then viewed by an\n\
4610  observer at altitude alt and azimuth az. This routine must be called\n\
4611  before plbox3 or plot3d. For a more complete description of\n\
4612  three-dimensional plotting see the PLplot documentation. \n\
4613 \n\
4614  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4615  zmin, zmax, alt, az)\n\
4616 \n\
4617  This function is examples 8,11,18,21. \n\
4618 \n\
4619 \n\
4620 \n\
4621 SYNOPSIS:\n\
4622 \n\
4623 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4624 \n\
4625 ARGUMENTS:\n\
4626 \n\
4627  basex (PLFLT, input) : The x coordinate size of the\n\
4628  world-coordinate box. \n\
4629 \n\
4630  basey (PLFLT, input) : The y coordinate size of the\n\
4631  world-coordinate box. \n\
4632 \n\
4633  height (PLFLT, input) : The z coordinate size of the\n\
4634  world-coordinate box. \n\
4635 \n\
4636  xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4637 \n\
4638  xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4639 \n\
4640  ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4641 \n\
4642  ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4643 \n\
4644  zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4645 \n\
4646  zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4647 \n\
4648  alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4649  plane. \n\
4650 \n\
4651  az (PLFLT, input) : The viewing azimuth in degrees. When az=0 ,\n\
4652  the observer is looking face onto the ZX plane, and as az is\n\
4653  increased, the observer moves clockwise around the box when viewed\n\
4654  from above the XY plane. \n\
4655 ";
4656 const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4657 Draw filled polygon \n\
4658 \n\
4659 DESCRIPTION:\n\
4660 \n\
4661  Fills the polygon defined by the n points (\n\
4662  x[i], \n\
4663  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4664  style is a solid fill. The routine will automatically close the\n\
4665  polygon between the last and first vertices. If multiple closed\n\
4666  polygons are passed in x and y then plfill will fill in between them. \n\
4667 \n\
4668  Redacted form: plfill(x,y)\n\
4669 \n\
4670  This function is used in examples 12,13,15,16,21,24,25. \n\
4671 \n\
4672 \n\
4673 \n\
4674 SYNOPSIS:\n\
4675 \n\
4676 plfill(n, x, y)\n\
4677 \n\
4678 ARGUMENTS:\n\
4679 \n\
4680  n (PLINT, input) : Number of vertices in polygon. \n\
4681 \n\
4682  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
4683  vertices. \n\
4684 \n\
4685  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
4686  vertices. \n\
4687 ";
4688 const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
4689 Magnitude colored plot surface with contour \n\
4690 \n\
4691 DESCRIPTION:\n\
4692 \n\
4693  Aside from dropping the \n\
4694  side functionality this is a more powerful form of plot3d: the surface\n\
4695  mesh can be colored accordingly to the current z value being plotted,\n\
4696  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
4697  drawn between the plotted function border and the base XY plane. The\n\
4698  arguments are identical to those of plmeshc. The only difference\n\
4699  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
4700  the surface, while plot3dc only draws the surface as viewed from the\n\
4701  top. \n\
4702 \n\
4703  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
4704 \t Perl/PDL: Not available? \n\
4705 \n\
4706 \n\
4707  This function is used in example 21. \n\
4708 \n\
4709 \n\
4710 \n\
4711 SYNOPSIS:\n\
4712 \n\
4713 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4714 \n\
4715 ARGUMENTS:\n\
4716 \n\
4717  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
4718  which the function is evaluated. \n\
4719 \n\
4720  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
4721  which the function is evaluated. \n\
4722 \n\
4723  z (const PLFLT * const *, input) : Pointer to a vectored\n\
4724  two-dimensional array with set of function values. \n\
4725 \n\
4726  nx (PLINT, input) : Number of x values at which function is\n\
4727  evaluated. \n\
4728 \n\
4729  ny (PLINT, input) : Number of y values at which function is\n\
4730  evaluated. \n\
4731 \n\
4732  opt (PLINT, input) : Determines the way in which the surface is\n\
4733  represented. To specify more than one option just add the options,\n\
4734  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
4735  showing z as a function of x for each value of y[j] . \n\
4736  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4737  for each value of x[i] . \n\
4738  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4739  at which function is defined. \n\
4740  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
4741  the z value being plotted. The color is used from the current\n\
4742  color map 1. \n\
4743  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4744  using parameters \n\
4745  nlevel and \n\
4746  clevel. \n\
4747  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4748  the borders of the plotted function. \n\
4749 \n\
4750 \n\
4751  clevel (const PLFLT *, input) : Pointer to the array that defines\n\
4752  the contour level spacing. \n\
4753 \n\
4754  nlevel (PLINT, input) : Number of elements in the clevel array. \n\
4755 ";
4756 const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
4757 Write text relative to viewport boundaries \n\
4758 \n\
4759 DESCRIPTION:\n\
4760 \n\
4761  Writes text at a specified position relative to the viewport\n\
4762  boundaries. Text may be written inside or outside the viewport, but\n\
4763  is clipped at the subpage boundaries. The reference point of a string\n\
4764  lies along a line passing through the string at half the height of a\n\
4765  capital letter. The position of the reference point along this line\n\
4766  is determined by just, and the position of the reference point\n\
4767  relative to the viewport is set by disp and pos. \n\
4768 \n\
4769  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4770 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4771 \n\
4772 \n\
4773  This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4774 \n\
4775 \n\
4776 \n\
4777 SYNOPSIS:\n\
4778 \n\
4779 plmtex(side, disp, pos, just, text)\n\
4780 \n\
4781 ARGUMENTS:\n\
4782 \n\
4783  side (const char *, input) : Specifies the side of the viewport\n\
4784  along which the text is to be written. The string must be one of:\n\
4785  b: Bottom of viewport, text written parallel to edge. \n\
4786  bv: Bottom of viewport, text written at right angles to edge. \n\
4787  l: Left of viewport, text written parallel to edge. \n\
4788  lv: Left of viewport, text written at right angles to edge. \n\
4789  r: Right of viewport, text written parallel to edge. \n\
4790  rv: Right of viewport, text written at right angles to edge. \n\
4791  t: Top of viewport, text written parallel to edge. \n\
4792  tv: Top of viewport, text written at right angles to edge. \n\
4793 \n\
4794 \n\
4795  disp (PLFLT, input) : Position of the reference point of string,\n\
4796  measured outwards from the specified viewport edge in units of the\n\
4797  current character height. Use negative disp to write within the\n\
4798  viewport. \n\
4799 \n\
4800  pos (PLFLT, input) : Position of the reference point of string\n\
4801  along the specified edge, expressed as a fraction of the length of\n\
4802  the edge. \n\
4803 \n\
4804  just (PLFLT, input) : Specifies the position of the string relative\n\
4805  to its reference point. If just=0. , the reference point is at\n\
4806  the left and if just=1. , it is at the right of the string. Other\n\
4807  values of just give intermediate justifications. \n\
4808 \n\
4809  text (const char *, input) : The string to be written out. \n\
4810 ";
4811 const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4812 Set arrow style for vector plots \n\
4813 \n\
4814 DESCRIPTION:\n\
4815 \n\
4816  Set the style for the arrow used by plvect to plot vectors. \n\
4817 \n\
4818  Redacted form: plsvect(arrowx, arrowy, fill)\n\
4819 \n\
4820  This function is used in example 22. \n\
4821 \n\
4822 \n\
4823 \n\
4824 SYNOPSIS:\n\
4825 \n\
4826 plsvect(arrowx, arrowy, npts, fill)\n\
4827 \n\
4828 ARGUMENTS:\n\
4829 \n\
4830  arrowx, arrowy (const PLFLT *,input) : Pointers to a pair of arrays\n\
4831  containing the x and y points which make up the arrow. The arrow\n\
4832  is plotted by joining these points to form a polygon. The scaling\n\
4833  assumes that the x and y points in the arrow lie in the range -0.5\n\
4834  <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n\
4835  style will be reset to its default. \n\
4836 \n\
4837  npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4838  arrowy. \n\
4839 \n\
4840  fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4841  fill is false then the arrow is open. \n\
4842 ";
4843 const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
4844 Get family file parameters \n\
4845 \n\
4846 DESCRIPTION:\n\
4847 \n\
4848  Gets information about current family file, if familying is enabled. \n\
4849  See the PLplot documentation for more information. \n\
4850 \n\
4851  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
4852 \n\
4853  This function is used in examples 14,31. \n\
4854 \n\
4855 \n\
4856 \n\
4857 SYNOPSIS:\n\
4858 \n\
4859 plgfam(p_fam, p_num, p_bmax)\n\
4860 \n\
4861 ARGUMENTS:\n\
4862 \n\
4863  p_fam (PLINT *, output) : Pointer to variable with the Boolean\n\
4864  family flag value. If nonzero, familying is enabled. \n\
4865 \n\
4866  p_num (PLINT *, output) : Pointer to variable with the current\n\
4867  family file number. \n\
4868 \n\
4869  p_bmax (PLINT *, output) : Pointer to variable with the maximum\n\
4870  file size (in bytes) for a family file. \n\
4871 ";
4872 const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
4873 Random number generator returning a real random number in the range [0,1] \n\
4874 \n\
4875 DESCRIPTION:\n\
4876 \n\
4877  Random number generator returning a real random number in the range\n\
4878  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4879  / compilers provide their own random number generator, and so this is\n\
4880  provided purely for convenience and to give a consistent random number\n\
4881  generator across all languages supported by PLplot. This is\n\
4882  particularly useful for comparing results from the test suite of\n\
4883  examples. \n\
4884 \n\
4885  Redacted form: plrandd()\n\
4886 \n\
4887  This function is used in examples 17,21. \n\
4888 \n\
4889 \n\
4890 \n\
4891 SYNOPSIS:\n\
4892 \n\
4893 plrandd()\n\
4894 ";
4895 const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
4896 Contour plot \n\
4897 \n\
4898 DESCRIPTION:\n\
4899 \n\
4900  Draws a contour plot of the data in f[\n\
4901  nx][\n\
4902  ny], using the nlevel contour levels specified by clevel. Only the\n\
4903  region of the array from kx to lx and from ky to ly is plotted out. A\n\
4904  transformation routine pointed to by pltr with a pointer pltr_data for\n\
4905  additional data required by the transformation routine is used to map\n\
4906  indices within the array to the world coordinates.\tSee the following\n\
4907  discussion of the arguments and the PLplot documentation for more\n\
4908  information. \n\
4909 \n\
4910  Redacted form: [PLEASE UPDATE! ONLY PERL INFO IS LIKELY CORRECT!] F95:\n\
4911  plcont(f, kx, lx, ky, ly, clevel, tr?) or plcont(f, kx, lx, ky, ly,\n\
4912  clevel, xgrid, ygrid)\n\
4913 \t Java: pls.cont(f, kx, lx, ky, ly, clevel, xgrid, ygrid)\n\
4914 \t Perl/PDL: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
4915 \t Python: plcont2(f, kx, lx, ky, ly, clevel)\n\
4916 \n\
4917 \n\
4918  This function is used in examples 9,14,16,22. \n\
4919 \n\
4920 \n\
4921 \n\
4922 SYNOPSIS:\n\
4923 \n\
4924 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
4925 \n\
4926 ARGUMENTS:\n\
4927 \n\
4928  f (const PLFLT * const *, input) : Pointer to a vectored\n\
4929  two-dimensional array containing data to be contoured. \n\
4930 \n\
4931  nx, ny (PLINT, input) : Physical dimensions of array f. \n\
4932 \n\
4933  kx, lx (PLINT, input) : Range of x indices to consider. \n\
4934 \n\
4935  ky, ly (PLINT, input) : Range of y indices to consider. \n\
4936 \n\
4937  clevel (const PLFLT *, input) : Pointer to array specifying levels\n\
4938  at which to draw contours. \n\
4939 \n\
4940  nlevel (PLINT, input) : Number of contour levels to draw. \n\
4941 \n\
4942  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
4943  Pointer to function that defines transformation between indices\n\
4944  in array f and the world coordinates (C only). Transformation\n\
4945  functions are provided in the PLplot library: pltr0 for identity\n\
4946  mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
4947  defined by one- and two-dimensional arrays. In addition,\n\
4948  user-supplied routines for the transformation can be used as well.\n\
4949  Examples of all of these approaches are given in the PLplot\n\
4950  documentation. The transformation function should have the form\n\
4951  given by any of pltr0, pltr1, or pltr2. Note that unlike plshades\n\
4952  and similar PLplot functions which have a pltr argument, plcont\n\
4953  requires that a transformation function be provided in the C\n\
4954  interface. Leaving pltr NULL will result in an error. \n\
4955 \n\
4956  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4957  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
4958  externally supplied. \n\
4959 ";
4960 const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
4961 Set line style \n\
4962 \n\
4963 DESCRIPTION:\n\
4964 \n\
4965  This sets up the line style for all lines subsequently drawn. A line\n\
4966  consists of segments in which the pen is alternately down and up. The\n\
4967  lengths of these segments are passed in the arrays mark and space\n\
4968  respectively. The number of mark-space pairs is specified by nms.\tIn\n\
4969  order to return the line style to the default continuous line, plstyl\n\
4970  should be called with nms=0 .(see also pllsty) \n\
4971 \n\
4972  Redacted form: plstyl(mark, space)\n\
4973 \n\
4974  This function is used in examples 1,9,14. \n\
4975 \n\
4976 \n\
4977 \n\
4978 SYNOPSIS:\n\
4979 \n\
4980 plstyl(nms, mark, space)\n\
4981 \n\
4982 ARGUMENTS:\n\
4983 \n\
4984  nms (PLINT, input) : The number of mark and space elements in a\n\
4985  line. Thus a simple broken line can be obtained by setting nms=1\n\
4986  . A continuous line is specified by setting nms=0 . \n\
4987 \n\
4988  mark (const PLINT *, input) : Pointer to array with the lengths of\n\
4989  the segments during which the pen is down, measured in\n\
4990  micrometers. \n\
4991 \n\
4992  space (const PLINT *, input) : Pointer to array with the lengths of\n\
4993  the segments during which the pen is up, measured in micrometers. \n\
4994 ";
4995 const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
4996 Set the colors for color table 0 from a cmap0 file \n\
4997 \n\
4998 DESCRIPTION:\n\
4999 \n\
5000  Set the colors for color table 0 from a cmap0 file \n\
5001 \n\
5002  Redacted form: plspal0(filename)\n\
5003 \n\
5004  This function is in example 16. \n\
5005 \n\
5006 \n\
5007 \n\
5008 SYNOPSIS:\n\
5009 \n\
5010 plspal0(filename)\n\
5011 \n\
5012 ARGUMENTS:\n\
5013 \n\
5014  filename (const char *, input) : The name of the cmap0 file, or a\n\
5015  empty to string to specify the default cmap0 file. \n\
5016 ";
5017 const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5018 Set the palette for cmap1 using the specified cmap1*.pal format file \n\
5019 \n\
5020 DESCRIPTION:\n\
5021 \n\
5022  Set the palette for cmap1 using the specified cmap1*.pal format file. \n\
5023 \n\
5024  Redacted form: plspal1(filename, interpolate)\n\
5025 \n\
5026  This function is used in example 16. \n\
5027 \n\
5028 \n\
5029 \n\
5030 SYNOPSIS:\n\
5031 \n\
5032 plspal1(filename, interpolate)\n\
5033 \n\
5034 ARGUMENTS:\n\
5035 \n\
5036  filename (const char *, input) : The name of the cmap1*.pal file,\n\
5037  or an empty string to specify the default cmap1.pal file. \n\
5038 \n\
5039  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5040  columns containing the intensity index, r, g, b, alpha and\n\
5041  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5042  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5043  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5044  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5045  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5046  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5047  are used instead to set the cmap1 palette directly with a call to\n\
5048  plscmap1a. \n\
5049 ";
5050 const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5051 Set current output stream \n\
5052 \n\
5053 DESCRIPTION:\n\
5054 \n\
5055  Sets the number of the current output stream. The stream number\n\
5056  defaults to 0 unless changed by this routine. The first use of this\n\
5057  routine must be followed by a call initializing PLplot (e.g. plstar). \n\
5058 \n\
5059  Redacted form: plsstrm(strm)\n\
5060 \n\
5061  This function is examples 1,14,20. \n\
5062 \n\
5063 \n\
5064 \n\
5065 SYNOPSIS:\n\
5066 \n\
5067 plsstrm(strm)\n\
5068 \n\
5069 ARGUMENTS:\n\
5070 \n\
5071  strm (PLINT, input) : The current stream number. \n\
5072 ";
5073 const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5074 Specify viewport using coordinates \n\
5075 \n\
5076 DESCRIPTION:\n\
5077 \n\
5078  Device-independent routine for setting up the viewport. This defines\n\
5079  the viewport in terms of normalized subpage coordinates which run from\n\
5080  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5081  current subpage. Use the alternate routine plsvpa in order to create\n\
5082  a viewport of a definite size. \n\
5083 \n\
5084  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5085 \n\
5086  This function is used in examples\n\
5087  2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
5088 \n\
5089 \n\
5090 \n\
5091 SYNOPSIS:\n\
5092 \n\
5093 plvpor(xmin, xmax, ymin, ymax)\n\
5094 \n\
5095 ARGUMENTS:\n\
5096 \n\
5097  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5098  left-hand edge of the viewport. \n\
5099 \n\
5100  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5101  right-hand edge of the viewport. \n\
5102 \n\
5103  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5104  bottom edge of the viewport. \n\
5105 \n\
5106  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5107  edge of the viewport. \n\
5108 ";
5109 const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5110 Write text inside the viewport \n\
5111 \n\
5112 DESCRIPTION:\n\
5113 \n\
5114  Writes text at a specified position and inclination within the\n\
5115  viewport. Text is clipped at the viewport boundaries. The reference\n\
5116  point of a string lies along a line passing through the string at half\n\
5117  the height of a capital letter. The position of the reference point\n\
5118  along this line is determined by just, the reference point is placed\n\
5119  at world coordinates (\n\
5120  x, \n\
5121  y)\twithin the viewport. The inclination of the string is specified\n\
5122  in terms of differences of world coordinates making it easy to write\n\
5123  text parallel to a line in a graph. \n\
5124 \n\
5125  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5126 \n\
5127  This function is used in example 2-4,10,12-14,20,23,24,26. \n\
5128 \n\
5129 \n\
5130 \n\
5131 SYNOPSIS:\n\
5132 \n\
5133 plptex(x, y, dx, dy, just, text)\n\
5134 \n\
5135 ARGUMENTS:\n\
5136 \n\
5137  x (PLFLT, input) : x coordinate of reference point of string. \n\
5138 \n\
5139  y (PLFLT, input) : y coordinate of reference point of string. \n\
5140 \n\
5141  dx (PLFLT, input) : Together with dy, this specifies the\n\
5142  inclination of the string. The baseline of the string is parallel\n\
5143  to a line joining (\n\
5144  x, \n\
5145  y) to (\n\
5146  x+\n\
5147  dx, \n\
5148  y+\n\
5149  dy) . \n\
5150 \n\
5151  dy (PLFLT, input) : Together with dx, this specifies the\n\
5152  inclination of the string. \n\
5153 \n\
5154  just (PLFLT, input) : Specifies the position of the string relative\n\
5155  to its reference point. If just=0. , the reference point is at\n\
5156  the left and if just=1. , it is at the right of the string. Other\n\
5157  values of just give intermediate justifications. \n\
5158 \n\
5159  text (const char *, input) : The string to be written out. \n\
5160 ";
5161 const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5162 Set z axis parameters \n\
5163 \n\
5164 DESCRIPTION:\n\
5165 \n\
5166  Identical to plsxax, except that arguments are flags for z axis. See\n\
5167  the description of plsxax for more detail. \n\
5168 \n\
5169  Redacted form: plszax(digmax, digits)\n\
5170 \n\
5171  This function is used in example 31. \n\
5172 \n\
5173 \n\
5174 \n\
5175 SYNOPSIS:\n\
5176 \n\
5177 plszax(digmax, digits)\n\
5178 \n\
5179 ARGUMENTS:\n\
5180 \n\
5181  digmax (PLINT, input) : Variable to set the maximum number of\n\
5182  digits for the z axis. If nonzero, the printed label will be\n\
5183  switched to a floating point representation when the number of\n\
5184  digits exceeds digmax. \n\
5185 \n\
5186  digits (PLINT, input) : Field digits value. Currently, changing\n\
5187  its value here has no effect since it is set only by plbox or\n\
5188  plbox3. However, the user may obtain its value after a call to\n\
5189  either of these functions by calling plgzax. \n\
5190 ";
5191 const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5192 Plot shaded 3-d surface plot for z[x][y] with y index limits \n\
5193 \n\
5194 DESCRIPTION:\n\
5195 \n\
5196  This variant of plsurf3d (see that function\'s documentation for more\n\
5197  details) should be suitable for the case where the area of the x, y\n\
5198  coordinate grid where z is defined can be non-rectangular.\tThe limits\n\
5199  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5200  indexymin, and indexymax. \n\
5201 \n\
5202  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5203  indexymax) \n\
5204 \n\
5205  This function is used in example 8. \n\
5206 \n\
5207 \n\
5208 \n\
5209 SYNOPSIS:\n\
5210 \n\
5211 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5212 \n\
5213 ARGUMENTS:\n\
5214 \n\
5215  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
5216  which the function is evaluated. \n\
5217 \n\
5218  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
5219  which the function is evaluated. \n\
5220 \n\
5221  z (const PLFLT * const *, input) : Pointer to a vectored\n\
5222  two-dimensional array with set of function values. \n\
5223 \n\
5224  nx (PLINT, input) : Number of x values at which function is\n\
5225  evaluated. \n\
5226 \n\
5227  ny (PLINT, input) : Number of y values at which function is\n\
5228  evaluated. \n\
5229 \n\
5230  opt (PLINT, input) : Determines the way in which the surface is\n\
5231  represented. To specify more than one option just add the options,\n\
5232  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5233  connecting points at which function is defined. \n\
5234  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5235  using parameters \n\
5236  nlevel and \n\
5237  clevel. \n\
5238  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5239  using parameters \n\
5240  nlevel and \n\
5241  clevel. \n\
5242  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5243  the borders of the plotted function. \n\
5244  opt=MAG_COLOR : the surface is colored according to the value\n\
5245  of Z; if MAG_COLOR is not used, then the default the surface\n\
5246  is colored according to the intensity of the reflected light\n\
5247  in the surface from a light source whose position is set using\n\
5248  pllightsource. \n\
5249 \n\
5250 \n\
5251  clevel (const PLFLT *, input) : Pointer to the array that defines\n\
5252  the contour level spacing. \n\
5253 \n\
5254  nlevel (PLINT, input) : Number of elements in the clevel array. \n\
5255 \n\
5256  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5257  corresponds to the first x index where z is defined. \n\
5258 \n\
5259  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5260  which corresponds (by convention) to one more than the last x\n\
5261  index value where z is defined. \n\
5262 \n\
5263  indexymin (const PLINT *, input) : Array of y index values which\n\
5264  all must be ≥ 0. These values are the first y index where z is\n\
5265  defined for a particular x index in the range from indexxmin to\n\
5266  indexxmax - 1. The dimension of indexymin is indexxmax. \n\
5267 \n\
5268  indexymax (const PLINT *, input) : Array of y index values which\n\
5269  all must be ≤ ny. These values correspond (by convention) to one\n\
5270  more than the last y index where z is defined for a particular x\n\
5271  index in the range from indexxmin to indexxmax - 1. The dimension\n\
5272  of indexymax is indexxmax. \n\
5273 ";
5274 const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5275 Set character font \n\
5276 \n\
5277 DESCRIPTION:\n\
5278 \n\
5279  Sets the default character font for subsequent character drawing. Also\n\
5280  affects symbols produced by plpoin. This routine has no effect unless\n\
5281  the extended character set is loaded (see plfontld). \n\
5282 \n\
5283  Redacted form: plfont(ifont)\n\
5284 \n\
5285  This function is used in examples 1,2,4,7,13,24,26. \n\
5286 \n\
5287 \n\
5288 \n\
5289 SYNOPSIS:\n\
5290 \n\
5291 plfont(ifont)\n\
5292 \n\
5293 ARGUMENTS:\n\
5294 \n\
5295  ifont (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
5296  and fastest) \n\
5297  2: Roman font \n\
5298  3: Italic font \n\
5299  4: Script font \n\
5300 ";
5301 const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5302 Get the cmap1 argument range for continuous color plots \n\
5303 \n\
5304 DESCRIPTION:\n\
5305 \n\
5306  Get the cmap1 argument range for continuous color plots. (Use\n\
5307  plgsmap1_range to set the cmap1 argument range.) \n\
5308 \n\
5309  Redacted form: plgcmap1_range(min_color, max_color)\n\
5310 \n\
5311  This function is currently not used in any example. \n\
5312 \n\
5313 \n\
5314 \n\
5315 SYNOPSIS:\n\
5316 \n\
5317 plgcmap1_range(min_color, max_color)\n\
5318 \n\
5319 ARGUMENTS:\n\
5320 \n\
5321  min_color (PLFLT *, output) : Pointer to the current minimum cmap1\n\
5322  floating point argument. \n\
5323 \n\
5324  max_color (PLFLT *, output) : Pointer to the current maximum cmap1\n\
5325  floating point argument. \n\
5326 ";
5327 const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5328 Set the cmap1 argument range for continuous color plots \n\
5329 \n\
5330 DESCRIPTION:\n\
5331 \n\
5332  Set the cmap1 argument range for continuous color plots. If \n\
5333  min_color is greater than \n\
5334  max_color or \n\
5335  max_color is greater than 1.0 or \n\
5336  min_color is less than 0.0 then no change is made.\t(Use\n\
5337  plgcmap1_range to get the cmap1 argument range.) \n\
5338 \n\
5339  Redacted form: plscmap1_range(min_color, max_color)\n\
5340 \n\
5341  This function is currently used in example 33. \n\
5342 \n\
5343 \n\
5344 \n\
5345 SYNOPSIS:\n\
5346 \n\
5347 plscmap1_range(min_color, max_color)\n\
5348 \n\
5349 ARGUMENTS:\n\
5350 \n\
5351  min_color (PLFLT, input) : The minimum cmap1 floating point\n\
5352  argument. \n\
5353 \n\
5354  max_color (PLFLT, input) : The maximum cmap1 floating point\n\
5355  argument. \n\
5356 ";
5357 const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5358 Draw a circular or elliptical arc \n\
5359 \n\
5360 DESCRIPTION:\n\
5361 \n\
5362  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5363  semiminor axis b, starting at angle1 and ending at angle2. \n\
5364 \n\
5365  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5366  fill)\n\
5367 \n\
5368 \n\
5369  This function is used in examples 3 and 27. \n\
5370 \n\
5371 \n\
5372 \n\
5373 SYNOPSIS:\n\
5374 \n\
5375 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5376 \n\
5377 ARGUMENTS:\n\
5378 \n\
5379  x (PLFLT, input) : X coordinate of arc center. \n\
5380 \n\
5381  y (PLFLT, input) : Y coordinate of arc center. \n\
5382 \n\
5383  a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
5384 \n\
5385  b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
5386 \n\
5387  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5388  semimajor axis. \n\
5389 \n\
5390  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5391  semimajor axis. \n\
5392 \n\
5393  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5394  X-axis. \n\
5395 \n\
5396  fill (PLBOOL, input) : Draw a filled arc. \n\
5397 ";
5398 const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5399 Plot 3-d surface plot \n\
5400 \n\
5401 DESCRIPTION:\n\
5402 \n\
5403  Plots a three dimensional surface plot within the environment set up\n\
5404  by plw3d. The surface is defined by the two-dimensional array z[\n\
5405  nx][\n\
5406  ny] , the point z[i][j] being the value of the function at (\n\
5407  x[i], \n\
5408  y[j]) . Note that the points in arrays x and y do not need to be\n\
5409  equally spaced, but must be stored in ascending order. The parameter\n\
5410  opt controls the way in which the surface is displayed. For further\n\
5411  details see the PLplot documentation. The only difference between\n\
5412  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5413  while plot3d only draws the surface as viewed from the top. \n\
5414 \n\
5415  Redacted form: plot3d(x, y, z, opt, side)\n\
5416 \n\
5417  This function is used in examples 11,21. \n\
5418 \n\
5419 \n\
5420 \n\
5421 SYNOPSIS:\n\
5422 \n\
5423 plot3d(x, y, z, nx, ny, opt, side)\n\
5424 \n\
5425 ARGUMENTS:\n\
5426 \n\
5427  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
5428  which the function is evaluated. \n\
5429 \n\
5430  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
5431  which the function is evaluated. \n\
5432 \n\
5433  z (const PLFLT * const *, input) : Pointer to a vectored\n\
5434  two-dimensional array with set of function values. \n\
5435 \n\
5436  nx (PLINT, input) : Number of x values at which function is\n\
5437  evaluated. \n\
5438 \n\
5439  ny (PLINT, input) : Number of y values at which function is\n\
5440  evaluated. \n\
5441 \n\
5442  opt (PLINT, input) : Determines the way in which the surface is\n\
5443  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5444  function of x for each value of y[j] . \n\
5445  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5446  for each value of x[i] . \n\
5447  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5448  at which function is defined. \n\
5449 \n\
5450 \n\
5451  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5452  should be draw on the figure. If side is true sides are drawn,\n\
5453  otherwise no sides are drawn. \n\
5454 ";
5455 const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5456 Set area fill pattern \n\
5457 \n\
5458 DESCRIPTION:\n\
5459 \n\
5460  Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
5461  parallel lines with specified inclinations and spacings. The\n\
5462  arguments to this routine are the number of sets to use (1 or 2)\n\
5463  followed by two pointers to integer arrays (of 1 or 2 elements)\n\
5464  specifying the inclinations in tenths of a degree and the spacing in\n\
5465  micrometers. (also see plpsty) \n\
5466 \n\
5467  Redacted form: General: plpat(inc, del)\n\
5468 \t Perl/PDL: plpat(nlin, inc, del)\n\
5469 \n\
5470 \n\
5471  This function is used in example 15. \n\
5472 \n\
5473 \n\
5474 \n\
5475 SYNOPSIS:\n\
5476 \n\
5477 plpat(nlin, inc, del)\n\
5478 \n\
5479 ARGUMENTS:\n\
5480 \n\
5481  nlin (PLINT, input) : Number of sets of lines making up the\n\
5482  pattern, either 1 or 2. \n\
5483 \n\
5484  inc (const PLINT *, input) : Pointer to array with nlin elements.\n\
5485  Specifies the line inclination in tenths of a degree. (Should be\n\
5486  between -900 and 900). \n\
5487 \n\
5488  del (const PLINT *, input) : Pointer to array with nlin elements.\n\
5489  Specifies the spacing in micrometers between the lines making up\n\
5490  the pattern. \n\
5491 ";
5492 const char* _wrap_plshade1_texinfo = "-*- texinfo -*-\n\
5493 Shade individual region on the basis of value \n\
5494 \n\
5495 DESCRIPTION:\n\
5496 \n\
5497  Shade individual region on the basis of value. Use plshades if you\n\
5498  want to shade a number of contiguous regions using continuous colors. \n\
5499  In particular the edge contours are treated properly in plshades. If\n\
5500  you attempt to do contiguous regions with plshade1 (or plshade) the\n\
5501  contours at the edge of the shade are partially obliterated by\n\
5502  subsequent plots of contiguous shaded regions. plshade1 differs from\n\
5503  plshade by the type of the first argument.\tLook at the argument list\n\
5504  below, plcont and the PLplot documentation for more information about\n\
5505  the transformation from grid to world coordinates.\tShading NEEDS\n\
5506  DOCUMENTATION, but as a stopgap look at how plshade is used in\n\
5507  examples/c/x15c.c\n\
5508 \n\
5509  Redacted form: General: plshade1(a, defined, xmin, xmax, ymin, ymax,\n\
5510  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
5511  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
5512 \t Perl/PDL: plshade1(a, xmin, xmax, ymin, ymax, shade_min,\n\
5513  shade_max, sh_cmap, sh_color, sh_width, min_color, min_width,\n\
5514  max_color, max_width, fill, rectangular, defined, pltr, pltr_data)\n\
5515 \n\
5516 \n\
5517  This function is used in example 15. \n\
5518 \n\
5519 \n\
5520 \n\
5521 SYNOPSIS:\n\
5522 \n\
5523 plshade1(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\
5524 \n\
5525 ARGUMENTS:\n\
5526 \n\
5527  a (const PLFLT *, input) : Contains array to be plotted. The array\n\
5528  must have been declared as PLFLT a[nx][ny]. \n\
5529 \n\
5530  nx (PLINT, input) : First dimension of array \"a\". \n\
5531 \n\
5532  ny (PLINT, input) : Second dimension of array \"a\". \n\
5533 \n\
5534  defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n\
5535  specifying regions excluded from the shading plot. This function\n\
5536  accepts x and y coordinates as input arguments and must return 0\n\
5537  if the point is in the excluded region or 1 otherwise. This\n\
5538  argument can be NULL if all the values are valid. \n\
5539 \n\
5540  xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5541  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5542  at (xmax,ymin) and so on. \n\
5543 \n\
5544  xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5545  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5546  at (xmax,ymin) and so on. \n\
5547 \n\
5548  ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5549  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5550  at (xmax,ymin) and so on. \n\
5551 \n\
5552  ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
5553  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
5554  at (xmax,ymin) and so on. \n\
5555 \n\
5556  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
5557  be shaded. If shade_max <= shade_min, plshade1 does nothing. \n\
5558 \n\
5559  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
5560  be shaded. If shade_max <= shade_min, plshade1 does nothing. \n\
5561 \n\
5562  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0 , then\n\
5563  sh_color is interpreted as a color map 0 (integer) index. If\n\
5564  sh_cmap=1 , then sh_color is interpreted as a color map 1\n\
5565  floating-point index which ranges from 0. to 1. \n\
5566 \n\
5567  sh_color (PLFLT, input) : Defines color map index if cmap0 or color\n\
5568  map input value (ranging from 0. to 1.) if cmap1. \n\
5569 \n\
5570  sh_width (PLFLT, input) : Defines width used by the fill pattern. \n\
5571 \n\
5572  min_color (PLINT, input) : Defines pen color, width used by the\n\
5573  boundary of shaded region. The min values are used for the\n\
5574  shade_min boundary, and the max values are used on the shade_max\n\
5575  boundary. Set color and width to zero for no plotted boundaries. \n\
5576 \n\
5577  min_width (PLFLT, input) : Defines pen color, width used by the\n\
5578  boundary of shaded region. The min values are used for the\n\
5579  shade_min boundary, and the max values are used on the shade_max\n\
5580  boundary. Set color and width to zero for no plotted boundaries. \n\
5581 \n\
5582  max_color (PLINT, input) : Defines pen color, width used by the\n\
5583  boundary of shaded region. The min values are used for the\n\
5584  shade_min boundary, and the max values are used on the shade_max\n\
5585  boundary. Set color and width to zero for no plotted boundaries. \n\
5586 \n\
5587  max_width (PLFLT, input) : Defines pen color, width used by the\n\
5588  boundary of shaded region. The min values are used for the\n\
5589  shade_min boundary, and the max values are used on the shade_max\n\
5590  boundary. Set color and width to zero for no plotted boundaries. \n\
5591 \n\
5592  fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
5593  Routine used to fill the region. Use plfill. Future version of\n\
5594  plplot may have other fill routines. \n\
5595 \n\
5596  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5597  map to rectangles after coordinate transformation with pltrl. \n\
5598  Otherwise, set rectangular to false. If rectangular is set to\n\
5599  true, plshade tries to save time by filling large rectangles. \n\
5600  This optimization fails if the coordinate transformation distorts\n\
5601  the shape of rectangles. For example a plot in polar coordinates\n\
5602  has to have rectangular set to false. \n\
5603 \n\
5604  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
5605  Pointer to function that defines transformation between indices\n\
5606  in array z and the world coordinates (C only). Transformation\n\
5607  functions are provided in the PLplot library: pltr0 for identity\n\
5608  mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
5609  defined by one- and two-dimensional arrays. In addition,\n\
5610  user-supplied routines for the transformation can be used as well.\n\
5611  Examples of all of these approaches are given in the PLplot\n\
5612  documentation. The transformation function should have the form\n\
5613  given by any of pltr0, pltr1, or pltr2. \n\
5614 \n\
5615  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5616  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5617  externally supplied. \n\
5618 ";
5619 const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
5620 Get x axis parameters \n\
5621 \n\
5622 DESCRIPTION:\n\
5623 \n\
5624  Returns current values of the p_digmax and p_digits flags for the x\n\
5625  axis. p_digits is updated after the plot is drawn, so this routine\n\
5626  should only be called after the call to plbox (or plbox3) is complete.\n\
5627  See the PLplot documentation for more information. \n\
5628 \n\
5629  Redacted form: plgxax(p_digmax, p_digits)\n\
5630 \n\
5631  This function is used in example 31. \n\
5632 \n\
5633 \n\
5634 \n\
5635 SYNOPSIS:\n\
5636 \n\
5637 plgxax(p_digmax, p_digits)\n\
5638 \n\
5639 ARGUMENTS:\n\
5640 \n\
5641  p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5642  number of digits for the x axis. If nonzero, the printed label\n\
5643  has been switched to a floating point representation when the\n\
5644  number of digits exceeds p_digmax. \n\
5645 \n\
5646  p_digits (PLINT *, output) : Pointer to variable with the actual\n\
5647  number of digits for the numeric labels (x axis) from the last\n\
5648  plot. \n\
5649 ";
5650 const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
5651 Draw filled polygon in 3D \n\
5652 \n\
5653 DESCRIPTION:\n\
5654 \n\
5655  Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
5656  using the pattern defined by plpsty or plpat. The routine will\n\
5657  automatically close the polygon between the last and first vertices. \n\
5658  If multiple closed polygons are passed in x, y, and z then plfill3\n\
5659  will fill in between them. \n\
5660 \n\
5661  Redacted form: General: plfill3(x, y, z)\n\
5662 \t Perl/PDL: plfill3(n, x, y, z)\n\
5663 \n\
5664 \n\
5665  This function is used in example 15. \n\
5666 \n\
5667 \n\
5668 \n\
5669 SYNOPSIS:\n\
5670 \n\
5671 plfill3(n, x, y, z)\n\
5672 \n\
5673 ARGUMENTS:\n\
5674 \n\
5675  n (PLINT, input) : Number of vertices in polygon. \n\
5676 \n\
5677  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
5678  vertices. \n\
5679 \n\
5680  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
5681  vertices. \n\
5682 \n\
5683  z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
5684  vertices. \n\
5685 ";
5686 const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
5687 Set color, cmap0 \n\
5688 \n\
5689 DESCRIPTION:\n\
5690 \n\
5691  Sets the color index for cmap0 (see the PLplot documentation). \n\
5692 \n\
5693  Redacted form: plcol0(icol0)\n\
5694 \n\
5695  This function is used in examples 1-9,11-16,18-27,29. \n\
5696 \n\
5697 \n\
5698 \n\
5699 SYNOPSIS:\n\
5700 \n\
5701 plcol0(icol0)\n\
5702 \n\
5703 ARGUMENTS:\n\
5704 \n\
5705  icol0 (PLINT, input) : Integer representing the color. The\n\
5706  defaults at present are (these may change): \n\
5707  0 black (default background) \n\
5708  1 red (default foreground) \n\
5709  2 yellow \n\
5710  3 green \n\
5711  4 aquamarine \n\
5712  5 pink \n\
5713  6 wheat \n\
5714  7 grey \n\
5715  8 brown \n\
5716  9 blue \n\
5717  10 BlueViolet \n\
5718  11 cyan \n\
5719  12 turquoise \n\
5720  13 magenta \n\
5721  14 salmon \n\
5722  15 white \n\
5723 \n\
5724  Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
5725  change an individual color in the map0 color palette. \n\
5726 ";
5727 const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
5728 Draw text at points defined by Shapefile data in world coordinates \n\
5729 \n\
5730 DESCRIPTION:\n\
5731 \n\
5732  As per plmapline, however the items are plotted as text in the same\n\
5733  way as plptex. \n\
5734 \n\
5735  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
5736  miny, maxy, plotentry)\n\
5737 \n\
5738  This function is used in example 19. \n\
5739 \n\
5740 \n\
5741 \n\
5742 SYNOPSIS:\n\
5743 \n\
5744 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
5745 \n\
5746 ARGUMENTS:\n\
5747 \n\
5748  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5749  supplied function to transform the coordinates given in the\n\
5750  shapefile into a plot coordinate system. By using this transform,\n\
5751  we can change from a longitude, latitude coordinate to a polar\n\
5752  stereographic project, for example. Initially, x[0]..[n-1] are\n\
5753  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5754  After the call to mapform(), x[] and y[] should be replaced by the\n\
5755  corresponding plot coordinates. If no transform is desired,\n\
5756  mapform can be replaced by NULL. \n\
5757 \n\
5758  name (const char *, input) : The file name of a set of Shapefile\n\
5759  files without the file extension. \n\
5760 \n\
5761  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
5762  dy/dx. \n\
5763 \n\
5764  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
5765  dy/dx. \n\
5766 \n\
5767  just (PLFLT, input) : Set the justification of the text. The value\n\
5768  given will be the fraction of the distance along the string that\n\
5769  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
5770  centralized text and 1.0 gives right aligned text. \n\
5771 \n\
5772  text (const char *, input) : A NULL-terminated string of characters\n\
5773  to be drawn. \n\
5774 \n\
5775  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5776  be in the same units as used by the Shapefile. You could use a\n\
5777  very large negative number to plot everything, but you can improve\n\
5778  performance by limiting the area drawn. The units must match those\n\
5779  of the Shapefile projection, which may be for example longitude or\n\
5780  distance. The value of minx must be less than the value of maxx. \n\
5781 \n\
5782  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5783  use a very large number to plot everything, but you can improve\n\
5784  performance by limiting the area drawn. \n\
5785 \n\
5786  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5787  be in the same units as used by the Shapefile. You could use a\n\
5788  very large negative number to plot everything, but you can improve\n\
5789  performance by limiting the area drawn. The units must match those\n\
5790  of the Shapefile projection, which may be for example latitude or\n\
5791  distance. The value of miny must be less than the value of maxy. \n\
5792 \n\
5793  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5794  use a very large number to plot everything, but you can improve\n\
5795  performance by limiting the area drawn. \n\
5796 \n\
5797  plotentry (PLINT, input) : An integer indicating which text string\n\
5798  of the Shapefile (zero indexed) will be drawn. \n\
5799 ";
5800 const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
5801 Draw a line between two points \n\
5802 \n\
5803 DESCRIPTION:\n\
5804 \n\
5805  Joins the point (\n\
5806  x1, \n\
5807  y1) to (\n\
5808  x2, \n\
5809  y2). \n\
5810 \n\
5811  Redacted form: pljoin(x1,y1,x2,y2)\n\
5812 \n\
5813  This function is used in examples 3,14. \n\
5814 \n\
5815 \n\
5816 \n\
5817 SYNOPSIS:\n\
5818 \n\
5819 pljoin(x1, y1, x2, y2)\n\
5820 \n\
5821 ARGUMENTS:\n\
5822 \n\
5823  x1 (PLFLT, input) : x coordinate of first point. \n\
5824 \n\
5825  y1 (PLFLT, input) : y coordinate of first point. \n\
5826 \n\
5827  x2 (PLFLT, input) : x coordinate of second point. \n\
5828 \n\
5829  y2 (PLFLT, input) : y coordinate of second point. \n\
5830 ";
5831 const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
5832 Set color, cmap1 \n\
5833 \n\
5834 DESCRIPTION:\n\
5835 \n\
5836  Sets the color for cmap1 (see the PLplot documentation). \n\
5837 \n\
5838  Redacted form: plcol1(col1)\n\
5839 \n\
5840  This function is used in examples 12 and 21. \n\
5841 \n\
5842 \n\
5843 \n\
5844 SYNOPSIS:\n\
5845 \n\
5846 plcol1(col1)\n\
5847 \n\
5848 ARGUMENTS:\n\
5849 \n\
5850  col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
5851  and is mapped to color using the continuous map1 color palette\n\
5852  which by default ranges from blue to the background color to red. \n\
5853  The map1 palette can also be straightforwardly changed by the user\n\
5854  with plscmap1 or plscmap1l. \n\
5855 ";
5856 const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
5857 Set orientation \n\
5858 \n\
5859 DESCRIPTION:\n\
5860 \n\
5861  Set integer plot orientation parameter. This function is identical to\n\
5862  plsdiori except for the type of the argument, and should be used in\n\
5863  the same way. See the PLplot documentation for details. \n\
5864 \n\
5865  Redacted form: plsori(ori)\n\
5866 \n\
5867  This function is used in example 3. \n\
5868 \n\
5869 \n\
5870 \n\
5871 SYNOPSIS:\n\
5872 \n\
5873 plsori(ori)\n\
5874 \n\
5875 ARGUMENTS:\n\
5876 \n\
5877  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5878  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5879  angle. \n\
5880 ";
5881 const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
5882 Calculate continuous time from broken-down time for the current stream \n\
5883 \n\
5884 DESCRIPTION:\n\
5885 \n\
5886  Calculate continuous time, ctime, from broken-down time for the\n\
5887  current stream. The broken-down\n\
5888  time is specified by the following parameters: year, month, day, hour,\n\
5889  min, and sec. This function is the inverse of plbtime. \n\
5890 \n\
5891  The PLplot definition of broken-down time is a calendar time that\n\
5892  completely ignores all time zone offsets, i.e., it is the user\'s\n\
5893  responsibility to apply those offsets (if so desired) before using the\n\
5894  PLplot time API. By default broken-down time is defined using the\n\
5895  proleptic Gregorian calendar without the insertion of leap seconds and\n\
5896  continuous time is defined as the number of seconds since the Unix\n\
5897  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
5898  broken-down and continuous time are possible, see plconfigtime which\n\
5899  specifies that transformation for the current stream. \n\
5900 \n\
5901  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
5902  ctime)\n\
5903 \t Perl/PDL: Not available? \n\
5904 \n\
5905 \n\
5906  This function is used in example 29. \n\
5907 \n\
5908 \n\
5909 \n\
5910 SYNOPSIS:\n\
5911 \n\
5912 plctime(year, month, day, hour, min, sec, ctime)\n\
5913 \n\
5914 ARGUMENTS:\n\
5915 \n\
5916  year (PLINT, input) : Input year. \n\
5917 \n\
5918  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
5919  (December). \n\
5920 \n\
5921  day (PLINT, input) : Input day in range from 1 to 31. \n\
5922 \n\
5923  hour (PLINT, input) : Input hour in range from 0 to 23 \n\
5924 \n\
5925  min (PLINT, input) : Input minute in range from 0 to 59. \n\
5926 \n\
5927  sec (PLFLT, input) : Input second in floating range from 0. to 60. \n\
5928 \n\
5929  ctime (PLFLT *, output) : Continous time calculated from the\n\
5930  broken-down time specified by the previous parameters. \n\
5931 ";
5932 const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5933 Plot continental outline or shapefile data in world coordinates \n\
5934 \n\
5935 DESCRIPTION:\n\
5936 \n\
5937  Plots continental outlines or shapefile data in world coordinates. A\n\
5938  demonstration of how to use this function to create different \n\
5939  projections can be found in examples/c/x19c. Plplot is provided with\n\
5940  basic coastal outlines and USA state borders. These can be used\n\
5941  irrespective of whether Shapefile support is built into Plplot. With\n\
5942  Shapefile support this function can also be used with user Shapefiles,\n\
5943  in which case it will plot the entire contents of a Shapefile joining\n\
5944  each point of each Shapefile element with a line. Shapefiles have\n\
5945  become a popular standard for geographical data and data in this\n\
5946  format can be easily found from a number of online sources. Shapefile\n\
5947  data is actually provided as three or more files with the same\n\
5948  filename, but different extensions. The .shp and .shx files are\n\
5949  required for plotting Shapefile data with Plplot. \n\
5950 \n\
5951  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5952 \n\
5953  This function is used in example 19. \n\
5954 \n\
5955 \n\
5956 \n\
5957 SYNOPSIS:\n\
5958 \n\
5959 plmap(mapform, name, minx, maxx, miny, maxy)\n\
5960 \n\
5961 ARGUMENTS:\n\
5962 \n\
5963  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5964  supplied function to transform the original map data coordinates\n\
5965  to a new coordinate system. The Plplot supplied map data is\n\
5966  provided as latitudes and longitudes; other Shapefile data may be\n\
5967  provided in other coordinate systems as can be found in their .prj\n\
5968  plain text files. For example, by using this transform we can\n\
5969  change from a longitude, latitude coordinate to a polar\n\
5970  stereographic projection. Initially, x[0]..[n-1] are the original\n\
5971  x coordinates (longitudes for the Plplot suplied data) and\n\
5972  y[0]..y[n-1] are the corresponding y coordinates (latitudes for\n\
5973  the Plplot supplied data). After the call to mapform(), x[] and\n\
5974  y[] should be replaced by the corresponding plot coordinates. If\n\
5975  no transform is desired, mapform can be replaced by NULL. \n\
5976 \n\
5977  name (const char *, input) : A character string which determines\n\
5978  the type of map plotted. This is either one of the Plplot built\n\
5979  in maps or the file name of a set of Shapefile files without the\n\
5980  file extensions. For the Plplot built in maps the possible values\n\
5981  are: \"globe\" -- continental outlines \n\
5982  \"usa\" -- USA and state boundaries \n\
5983  \"cglobe\" -- continental outlines and countries \n\
5984  \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5985 \n\
5986 \n\
5987  minx (PLFLT, input) : The minimum x value of map elements to be\n\
5988  drawn. For the built in maps this is a measure of longitude. For\n\
5989  Shapefiles the units must match the projection. The value of minx\n\
5990  must be less than the value of maxx. Specifying a useful limit for\n\
5991  these limits provides a useful optimization for complex or\n\
5992  detailed maps. \n\
5993 \n\
5994  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5995  drawn \n\
5996 \n\
5997  miny (PLFLT, input) : The minimum y value of map elements to be\n\
5998  drawn. For the built in maps this is a measure of latitude. For\n\
5999  Shapefiles the units must match the projection. The value of miny\n\
6000  must be less than the value of maxy. \n\
6001 \n\
6002  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6003  drawn. \n\
6004 ";
6005 const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6006 Calculate broken-down time from continuous time for the current stream \n\
6007 \n\
6008 DESCRIPTION:\n\
6009 \n\
6010  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6011  continuous time, ctime for the current stream. This function is the\n\
6012  inverse of plctime. \n\
6013 \n\
6014  The PLplot definition of broken-down time is a calendar time that\n\
6015  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6016  responsibility to apply those offsets (if so desired) before using the\n\
6017  PLplot time API. By default broken-down time is defined using the\n\
6018  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6019  continuous time is defined as the number of seconds since the Unix\n\
6020  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6021  broken-down and continuous time are possible, see plconfigtime. \n\
6022 \n\
6023  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6024  ctime)\n\
6025 \t Perl/PDL: Not available? \n\
6026 \n\
6027 \n\
6028  This function is used in example 29. \n\
6029 \n\
6030 \n\
6031 \n\
6032 SYNOPSIS:\n\
6033 \n\
6034 plbtime(year, month, day, hour, min, sec, ctime)\n\
6035 \n\
6036 ARGUMENTS:\n\
6037 \n\
6038  year (PLINT *, output) : Output year. \n\
6039 \n\
6040  month (PLINT *, output) : Output month in range from 0 (January) to\n\
6041  11 (December). \n\
6042 \n\
6043  day (PLINT *, output) : Output day in range from 1 to 31. \n\
6044 \n\
6045  hour (PLINT *, output) : Output hour in range from 0 to 23. \n\
6046 \n\
6047  min (PLINT *, output) : Output minute in range from 0 to 59 \n\
6048 \n\
6049  sec (PLFLT *, output) : Output second in floating range from 0. to\n\
6050  60. \n\
6051 \n\
6052  ctime (PLFLT, input) : Continous time from which the broken-down\n\
6053  time is calculated. \n\
6054 ";
6055 const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6056 Get current stream number \n\
6057 \n\
6058 DESCRIPTION:\n\
6059 \n\
6060  Gets the number of the current output stream. See also plsstrm. \n\
6061 \n\
6062  Redacted form: plgstrm(p_strm)\n\
6063 \n\
6064  This function is used in example 1,20. \n\
6065 \n\
6066 \n\
6067 \n\
6068 SYNOPSIS:\n\
6069 \n\
6070 plgstrm(p_strm)\n\
6071 \n\
6072 ARGUMENTS:\n\
6073 \n\
6074  p_strm (PLINT *, output) : Pointer to current stream value. \n\
6075 ";
6076 const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6077 Draw a line in 3 space \n\
6078 \n\
6079 DESCRIPTION:\n\
6080 \n\
6081  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6082  first set up the viewport, the 2d viewing window (in world\n\
6083  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6084  more info. \n\
6085 \n\
6086  Redacted form: plline3(x, y, z)\n\
6087 \n\
6088  This function is used in example 18. \n\
6089 \n\
6090 \n\
6091 \n\
6092 SYNOPSIS:\n\
6093 \n\
6094 plline3(n, x, y, z)\n\
6095 \n\
6096 ARGUMENTS:\n\
6097 \n\
6098  n (PLINT, input) : Number of points defining line. \n\
6099 \n\
6100  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
6101  points. \n\
6102 \n\
6103  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
6104  points. \n\
6105 \n\
6106  z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
6107  points. \n\
6108 ";
6109 const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6110 Load character font \n\
6111 \n\
6112 DESCRIPTION:\n\
6113 \n\
6114  Sets the character set to use for subsequent character drawing. May\n\
6115  be called before initializing PLplot. \n\
6116 \n\
6117  Redacted form: plfontld(fnt)\n\
6118 \n\
6119  This function is used in examples 1,7. \n\
6120 \n\
6121 \n\
6122 \n\
6123 SYNOPSIS:\n\
6124 \n\
6125 plfontld(fnt)\n\
6126 \n\
6127 ARGUMENTS:\n\
6128 \n\
6129  fnt (PLINT, input) : Specifies the character set to load: 0:\n\
6130  Standard character set \n\
6131  1: Extended character set \n\
6132 ";
6133 const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6134 Set any command-line option \n\
6135 \n\
6136 DESCRIPTION:\n\
6137 \n\
6138  Set any command-line option internally from a program before it\n\
6139  invokes plinit. opt is the name of the command-line option and optarg\n\
6140  is the corresponding command-line option argument. \n\
6141 \n\
6142  This function returns 0 on success. \n\
6143 \n\
6144  Redacted form: plsetopt(opt, optarg)\n\
6145 \n\
6146  This function is used in example 14. \n\
6147 \n\
6148 \n\
6149 \n\
6150 SYNOPSIS:\n\
6151 \n\
6152 int plsetopt(opt, optarg)\n\
6153 \n\
6154 ARGUMENTS:\n\
6155 \n\
6156  opt (const char *, input) : Pointer to string containing the\n\
6157  command-line option. \n\
6158 \n\
6159  optarg (const char *, input) : Pointer to string containing the\n\
6160  argument of the command-line option. \n\
6161 ";
6162 const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6163 Plot all or a subset of Shapefile data using lines in world coordinates \n\
6164 \n\
6165 DESCRIPTION:\n\
6166 \n\
6167  Plot all or a subset of Shapefile data using lines in world\n\
6168  coordinates. examples/c/x19c demonstrates how to use this function.\n\
6169  This function plots data from a Shapefile using lines as in plmap,\n\
6170  however it also has the option of also only drawing specified elements\n\
6171  from the Shapefile. The indices of the required elements are passed\n\
6172  into the function as an array. The Shapefile data should include a\n\
6173  metadata file (extension.dbf) listing all items within the Shapefile.\n\
6174  This file can be opened by most popular spreadsheet programs and can\n\
6175  be used to decide which indices to pass to this function. \n\
6176 \n\
6177  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6178  plotentries)\n\
6179 \n\
6180  This function is used in example 19. \n\
6181 \n\
6182 \n\
6183 \n\
6184 SYNOPSIS:\n\
6185 \n\
6186 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6187 \n\
6188 ARGUMENTS:\n\
6189 \n\
6190  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
6191  supplied function to transform the coordinates given in the\n\
6192  shapefile into a plot coordinate system. By using this transform,\n\
6193  we can change from a longitude, latitude coordinate to a polar\n\
6194  stereographic project, for example. Initially, x[0]..[n-1] are\n\
6195  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
6196  After the call to mapform(), x[] and y[] should be replaced by the\n\
6197  corresponding plot coordinates. If no transform is desired,\n\
6198  mapform can be replaced by NULL. \n\
6199 \n\
6200  name (const char *, input) : The file name of a set of Shapefile\n\
6201  files without the file extension. \n\
6202 \n\
6203  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6204  be in the same units as used by the Shapefile. You could use a\n\
6205  very large negative number to plot everything, but you can improve\n\
6206  performance by limiting the area drawn. The units must match those\n\
6207  of the Shapefile projection, which may be for example longitude or\n\
6208  distance. The value of minx must be less than the value of maxx. \n\
6209 \n\
6210  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6211  use a very large number to plot everything, but you can improve\n\
6212  performance by limiting the area drawn. \n\
6213 \n\
6214  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6215  be in the same units as used by the Shapefile. You could use a\n\
6216  very large negative number to plot everything, but you can improve\n\
6217  performance by limiting the area drawn. The units must match those\n\
6218  of the Shapefile projection, which may be for example latitude or\n\
6219  distance. The value of miny must be less than the value of maxy. \n\
6220 \n\
6221  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6222  use a very large number to plot everything, but you can improve\n\
6223  performance by limiting the area drawn. \n\
6224 \n\
6225  plotentries (const PLINT *, input) : An array of integers\n\
6226  indicating the elements of the Shapefile (zero indexed) which will\n\
6227  be drawn. Setting plotentries to NULL will plot all elements of\n\
6228  the Shapefile. \n\
6229 \n\
6230  nplotentries (PLINT, input) : The number of items in plotentries.\n\
6231  Ignored if plotentries is NULL. \n\
6232 ";
6233 const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6234 Used to globally turn color output on/off \n\
6235 \n\
6236 DESCRIPTION:\n\
6237 \n\
6238  Used to globally turn color output on/off for those drivers/devices\n\
6239  that support it. \n\
6240 \n\
6241  Redacted form: plscolor(color)\n\
6242 \n\
6243  This function is used in example 31. \n\
6244 \n\
6245 \n\
6246 \n\
6247 SYNOPSIS:\n\
6248 \n\
6249 plscolor(color)\n\
6250 \n\
6251 ARGUMENTS:\n\
6252 \n\
6253  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6254  turned off. If non-zero, color is turned on. \n\
6255 ";
6256 const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6257 Get the current device (keyword) name \n\
6258 \n\
6259 DESCRIPTION:\n\
6260 \n\
6261  Get the current device (keyword) name. Note: you must have allocated\n\
6262  space for this (80 characters is safe). \n\
6263 \n\
6264  Redacted form: plgdev(p_dev)\n\
6265 \n\
6266  This function is used in example 14. \n\
6267 \n\
6268 \n\
6269 \n\
6270 SYNOPSIS:\n\
6271 \n\
6272 plgdev(p_dev)\n\
6273 \n\
6274 ARGUMENTS:\n\
6275 \n\
6276  p_dev (char *, output) : Pointer to device (keyword) name string. \n\
6277 ";
6278 const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6279 Add a point to a strip chart \n\
6280 \n\
6281 DESCRIPTION:\n\
6282 \n\
6283  Add a point to a given pen of a given strip chart. There is no need\n\
6284  for all pens to have the same number of points or to be equally\n\
6285  sampled in the x coordinate. Allocates memory and rescales as\n\
6286  necessary. \n\
6287 \n\
6288  Redacted form: plstripa(id, pen, x, y)\n\
6289 \n\
6290  This function is used in example 17. \n\
6291 \n\
6292 \n\
6293 \n\
6294 SYNOPSIS:\n\
6295 \n\
6296 plstripa(id, pen, x, y)\n\
6297 \n\
6298 ARGUMENTS:\n\
6299 \n\
6300  id (PLINT, input) : Identification number of the strip chart (set\n\
6301  up in plstripc). \n\
6302 \n\
6303  pen (PLINT, input) : Pen number (ranges from 0 to 3). \n\
6304 \n\
6305  x (PLFLT, input) : X coordinate of point to plot. \n\
6306 \n\
6307  y (PLFLT, input) : Y coordinate of point to plot. \n\
6308 ";
6309 const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6310 Create a 4-pen strip chart \n\
6311 \n\
6312 DESCRIPTION:\n\
6313 \n\
6314  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6315 \n\
6316  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6317  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6318  styline, legline, labx, laby, labz)\n\
6319 \t Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n\
6320  ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n\
6321  ypsec, legline, labx, laby, labtop)\n\
6322 \n\
6323 \n\
6324  This function is used in example 17. \n\
6325 \n\
6326 \n\
6327 \n\
6328 SYNOPSIS:\n\
6329 \n\
6330 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6331 \n\
6332 ARGUMENTS:\n\
6333 \n\
6334  id (PLINT *, output) : Identification number of strip chart to use\n\
6335  on plstripa and plstripd. \n\
6336 \n\
6337  xspec (const char *, input) : X-axis specification as in plbox. \n\
6338 \n\
6339  yspec (const char *, input) : Y-axis specification as in plbox. \n\
6340 \n\
6341  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6342  change as data are added. \n\
6343 \n\
6344  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6345  change as data are added. \n\
6346 \n\
6347  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6348  is multiplied by the factor (1 + \n\
6349  xjump) . \n\
6350 \n\
6351  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6352  change as data are added. \n\
6353 \n\
6354  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6355  change as data are added. \n\
6356 \n\
6357  xlpos (PLFLT, input) : X legend box position (range from 0 to 1). \n\
6358 \n\
6359  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1). \n\
6360 \n\
6361  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6362  true, otherwise not. \n\
6363 \n\
6364  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6365  otherwise slide display. \n\
6366 \n\
6367  colbox (PLINT, input) : Plot box color index (cmap0). \n\
6368 \n\
6369  collab (PLINT, input) : Legend color index (cmap0). \n\
6370 \n\
6371  colline (const PLINT *, input) : Pointer to array with color\n\
6372  indices (cmap0) for the 4 pens. \n\
6373 \n\
6374  styline (const PLINT *, input) : Pointer to array with line styles\n\
6375  for the 4 pens. \n\
6376 \n\
6377  legline (const char **, input) : Pointer to character array\n\
6378  containing legends for the 4 pens. \n\
6379 \n\
6380  labx (const char *, input) : X-axis label. \n\
6381 \n\
6382  laby (const char *, input) : Y-axis label. \n\
6383 \n\
6384  labtop (const char *, input) : Plot title. \n\
6385 ";
6386 const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6387 Deletes and releases memory used by a strip chart \n\
6388 \n\
6389 DESCRIPTION:\n\
6390 \n\
6391  Deletes and releases memory used by a strip chart. \n\
6392 \n\
6393  Redacted form: plstripd(id)\n\
6394 \n\
6395  This function is used in example 17. \n\
6396 \n\
6397 \n\
6398 \n\
6399 SYNOPSIS:\n\
6400 \n\
6401 plstripd(id)\n\
6402 \n\
6403 ARGUMENTS:\n\
6404 \n\
6405  id (PLINT, input) : Identification number of strip chart to delete. \n\
6406 ";
6407 const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6408 Specify viewport using coordinates and aspect ratio \n\
6409 \n\
6410 DESCRIPTION:\n\
6411 \n\
6412  Device-independent routine for setting up the viewport. The viewport\n\
6413  is chosen to be the largest with the given aspect ratio that fits\n\
6414  within the specified region (in terms of normalized subpage\n\
6415  coordinates). This routine is functionally equivalent to plvpor when\n\
6416  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6417  routine reserves no extra space at the edges for labels. \n\
6418 \n\
6419  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6420 \n\
6421  This function is used in example 9. \n\
6422 \n\
6423 \n\
6424 \n\
6425 SYNOPSIS:\n\
6426 \n\
6427 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6428 \n\
6429 ARGUMENTS:\n\
6430 \n\
6431  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6432  left-hand edge of the viewport. \n\
6433 \n\
6434  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6435  right-hand edge of the viewport. \n\
6436 \n\
6437  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6438  bottom edge of the viewport. \n\
6439 \n\
6440  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6441  edge of the viewport. \n\
6442 \n\
6443  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6444  axis. \n\
6445 ";
6446 const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6447 Assign a function to use for generating custom axis labels \n\
6448 \n\
6449 DESCRIPTION:\n\
6450 \n\
6451  This function allows a user to provide their own function to provide\n\
6452  axis label text. The user function is given the numeric value for a\n\
6453  point on an axis and returns a string label to correspond with that\n\
6454  value. Custom axis labels can be enabled by passing appropriate\n\
6455  arguments to plenv, plbox, plbox3 and similar functions. \n\
6456 \n\
6457  This function is used in example 19. \n\
6458 \n\
6459 \n\
6460 \n\
6461 SYNOPSIS:\n\
6462 \n\
6463 plslabelfunc(label_func, label_data)\n\
6464 \n\
6465 ARGUMENTS:\n\
6466 \n\
6467  label_func (void (*) (PLINT, PLFLT, char *, PLINT, PLPointer), input)\n\
6468  : This is the custom label function. In order to reset to the\n\
6469  default labelling, set this to NULL. The labelling function\n\
6470  parameters are, in order: axis: This indicates which axis a\n\
6471  label is being requested for. The value will be one of PL_X_AXIS,\n\
6472  PL_Y_AXIS or PL_Z_AXIS. \n\
6473 \n\
6474  value: This is the value along the axis which is being labelled. \n\
6475 \n\
6476  label_text: The string representation of the label value. \n\
6477 \n\
6478  length: The maximum length in characters allowed for label_text. \n\
6479 \n\
6480 \n\
6481  label_data (PLPointer, input) : This parameter may be used to pass\n\
6482  data to the label_func function. \n\
6483 ";
6484 const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6485 Set length of major ticks \n\
6486 \n\
6487 DESCRIPTION:\n\
6488 \n\
6489  This sets up the length of the major ticks. The actual length is the\n\
6490  product of the default length and a scaling factor as for character\n\
6491  height. \n\
6492 \n\
6493  Redacted form: plsmaj(def, scale)\n\
6494 \n\
6495  This function is used in example 29. \n\
6496 \n\
6497 \n\
6498 \n\
6499 SYNOPSIS:\n\
6500 \n\
6501 plsmaj(def, scale)\n\
6502 \n\
6503 ARGUMENTS:\n\
6504 \n\
6505  def (PLFLT, input) : The default length of a major tick in\n\
6506  millimeters, should be set to zero if the default length is to\n\
6507  remain unchanged. \n\
6508 \n\
6509  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6510  actual tick length. \n\
6511 ";
6512 const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6513 Get the current library version number \n\
6514 \n\
6515 DESCRIPTION:\n\
6516 \n\
6517  Get the current library version number. Note: you must have allocated\n\
6518  space for this (80 characters is safe). \n\
6519 \n\
6520  Redacted form: plgver(p_ver)\n\
6521 \n\
6522  This function is used in example 1. \n\
6523 \n\
6524 \n\
6525 \n\
6526 SYNOPSIS:\n\
6527 \n\
6528 plgver(p_ver)\n\
6529 \n\
6530 ARGUMENTS:\n\
6531 \n\
6532  p_ver (char *, output) : Pointer to the current library version\n\
6533  number. \n\
6534 ";
6535 const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6536 Set format of numerical label for contours\n\
6537 \n\
6538 DESCRIPTION:\n\
6539 \n\
6540  Set format of numerical label for contours. \n\
6541 \n\
6542  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6543 \n\
6544  This function is used example 9. \n\
6545 \n\
6546 \n\
6547 \n\
6548 SYNOPSIS:\n\
6549 \n\
6550 pl_setcontlabelformat(lexp, sigdig)\n\
6551 \n\
6552 ARGUMENTS:\n\
6553 \n\
6554  lexp (PLINT, input) : If the contour numerical label is greater\n\
6555  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6556  format is used. Default value of lexp is 4. \n\
6557 \n\
6558  sigdig (PLINT, input) : Number of significant digits. Default\n\
6559  value is 2. \n\
6560 ";
6561 const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6562 Parse command-line arguments \n\
6563 \n\
6564 DESCRIPTION:\n\
6565 \n\
6566  Parse command-line arguments. \n\
6567 \n\
6568  plparseopts removes all recognized flags (decreasing argc\n\
6569  accordingly), so that invalid input may be readily detected. It can\n\
6570  also be used to process user command line flags. The user can merge\n\
6571  an option table of type PLOptionTable into the internal option table\n\
6572  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6573  the external table(s) be parsed by calling plClearOpts before\n\
6574  plMergeOpts. \n\
6575 \n\
6576  The default action taken by plparseopts is as follows: \n\
6577  Returns with an error if an unrecognized option or badly formed\n\
6578  option-value pair are encountered.\t\n\
6579  Returns immediately (return code 0) when the first non-option command\n\
6580  line argument is found. \n\
6581  Returns with the return code of the option handler, if one was called.\n\
6582  \n\
6583  Deletes command line arguments from argv list as they are found, and\n\
6584  decrements argc accordingly. \n\
6585  Does not show \"invisible\" options in usage or help messages. \n\
6586  Assumes the program name is contained in argv[0]. \n\
6587 \n\
6588  These behaviors may be controlled through the \n\
6589  mode argument. \n\
6590 \n\
6591  Redacted form: General: plparseopts(argv, mode)\n\
6592 \t Perl/PDL: Not available? \n\
6593 \n\
6594 \n\
6595  This function is used in all of the examples. \n\
6596 \n\
6597 \n\
6598 \n\
6599 SYNOPSIS:\n\
6600 \n\
6601 int plparseopts(p_argc, argv, mode)\n\
6602 \n\
6603 ARGUMENTS:\n\
6604 \n\
6605  p_argc (int *, input) : pointer to number of arguments. \n\
6606 \n\
6607  argv (const char **, input) : Pointer to character array containing\n\
6608  *p_argc command-line arguments. \n\
6609 \n\
6610  mode (PLINT, input) : Parsing mode with the following\n\
6611  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6612  and all error messages enabled, including program exit when an\n\
6613  error occurs. Anything on the command line that isn\'t recognized\n\
6614  as a valid option or option argument is flagged as an error. \n\
6615  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6616  of errors. \n\
6617  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6618  arguments. \n\
6619  PL_PARSE_SHOWALL (8) -- Show invisible options \n\
6620  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6621  pointer to the program name. \n\
6622  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
6623  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6624  unrecognized arguments. \n\
6625 ";
6626 const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
6627 Initialization \n\
6628 \n\
6629 DESCRIPTION:\n\
6630 \n\
6631  Initializing the plotting package.\tThe program prompts for the device\n\
6632  keyword or number of the desired output device. Hitting a RETURN in\n\
6633  response to the prompt is the same as selecting the first device. If\n\
6634  only one device is enabled when PLplot is installed, plstar will issue\n\
6635  no prompt.\tThe output device is divided into nx by ny subpages, each\n\
6636  of which may be used independently. The subroutine pladv is used to\n\
6637  advance from one subpage to the next. \n\
6638 \n\
6639  Redacted form: plstar(nx, ny)\n\
6640 \n\
6641  This function is used in example 1. \n\
6642 \n\
6643 \n\
6644 \n\
6645 SYNOPSIS:\n\
6646 \n\
6647 plstar(nx, ny)\n\
6648 \n\
6649 ARGUMENTS:\n\
6650 \n\
6651  nx (PLINT, input) : Number of subpages to divide output page in the\n\
6652  horizontal direction. \n\
6653 \n\
6654  ny (PLINT, input) : Number of subpages to divide output page in the\n\
6655  vertical direction. \n\
6656 ";
6657 const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
6658 Get FCI (font characterization integer) \n\
6659 \n\
6660 DESCRIPTION:\n\
6661 \n\
6662  Gets information about the current font using the FCI approach. See\n\
6663  the PLplot documentation for more information. \n\
6664 \n\
6665  Redacted form: plgfci(p_fci)\n\
6666 \n\
6667  This function is used in example 23. \n\
6668 \n\
6669 \n\
6670 \n\
6671 SYNOPSIS:\n\
6672 \n\
6673 plgfci(p_fci)\n\
6674 \n\
6675 ARGUMENTS:\n\
6676 \n\
6677  p_fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
6678  integer) variable which is updated with current FCI value. \n\
6679 ";
6680 const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
6681 Set family file parameters \n\
6682 \n\
6683 DESCRIPTION:\n\
6684 \n\
6685  Sets variables dealing with output file familying.\tDoes nothing if\n\
6686  familying not supported by the driver. This routine, if used, must be\n\
6687  called before initializing PLplot.\tSee the PLplot documentation for\n\
6688  more information. \n\
6689 \n\
6690  Redacted form: plsfam(fam, num, bmax)\n\
6691 \n\
6692  This function is used in examples 14,31. \n\
6693 \n\
6694 \n\
6695 \n\
6696 SYNOPSIS:\n\
6697 \n\
6698 plsfam(fam, num, bmax)\n\
6699 \n\
6700 ARGUMENTS:\n\
6701 \n\
6702  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
6703  is enabled. \n\
6704 \n\
6705  num (PLINT, input) : Current family file number. \n\
6706 \n\
6707  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
6708  file. \n\
6709 ";
6710 const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
6711 Set cmap1 colors and alpha transparency using a piece-wise linear relationship \n\
6712 \n\
6713 DESCRIPTION:\n\
6714 \n\
6715  This is a variant of plscmap1l that supports alpha channel\n\
6716  transparency. It sets cmap1 colors using a piece-wise linear\n\
6717  relationship between cmap1 intensity index (from 0. to 1.) and\n\
6718  position in HLS or RGB color space (see the PLplot documentation) with\n\
6719  alpha transparency value (0.0 - 1.0). It may be called at any time. \n\
6720 \n\
6721  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
6722  alpha, alt_hue_path) \n\
6723 \n\
6724  This function is used in example 30. \n\
6725 \n\
6726 \n\
6727 \n\
6728 SYNOPSIS:\n\
6729 \n\
6730 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
6731 \n\
6732 ARGUMENTS:\n\
6733 \n\
6734  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
6735 \n\
6736  npts (PLINT, input) : number of control points \n\
6737 \n\
6738  intensity (const PLFLT *, input) : position for each control point\n\
6739  (between 0.0 and 1.0, in ascending order) \n\
6740 \n\
6741  coord1 (const PLFLT *, input) : first coordinate (H or R) for each\n\
6742  control point \n\
6743 \n\
6744  coord2 (const PLFLT *, input) : second coordinate (L or G) for each\n\
6745  control point \n\
6746 \n\
6747  coord3 (const PLFLT *, input) : third coordinate (S or B) for each\n\
6748  control point \n\
6749 \n\
6750  alpha (const PLFLT *, input) : the alpha transparency value for\n\
6751  each control point \n\
6752 \n\
6753  alt_hue_path (const PLBOOL *, input) : alternative interpolation\n\
6754  method flag for each control point. (alt_hue_path[i] refers to the\n\
6755  interpolation interval between the i and i + 1 control points). \n\
6756 ";
6757 const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
6758 Set page parameters \n\
6759 \n\
6760 DESCRIPTION:\n\
6761 \n\
6762  Sets the page configuration (optional). If an individual parameter is\n\
6763  zero then that parameter value is not updated. Not all parameters are\n\
6764  recognized by all drivers and the interpretation is device-dependent.\n\
6765  The X-window driver uses the length and offset parameters to determine\n\
6766  the window size and location. The length and offset values are\n\
6767  expressed in units that are specific to the current driver. For\n\
6768  instance: screen drivers will usually interpret them as number of\n\
6769  pixels, whereas printer drivers will usually use mm. This routine, if\n\
6770  used, must be called before initializing PLplot. \n\
6771 \n\
6772  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6773 \n\
6774  This function is used in examples 14 and 31. \n\
6775 \n\
6776 \n\
6777 \n\
6778 SYNOPSIS:\n\
6779 \n\
6780 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6781 \n\
6782 ARGUMENTS:\n\
6783 \n\
6784  xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
6785 \n\
6786  yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
6787 \n\
6788  xleng (PLINT , input) : Page length, x. \n\
6789 \n\
6790  yleng (PLINT, input) : Page length, y. \n\
6791 \n\
6792  xoff (PLINT, input) : Page offset, x. \n\
6793 \n\
6794  yoff (PLINT, input) : Page offset, y. \n\
6795 ";
6796 const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
6797 Set precision in numeric labels \n\
6798 \n\
6799 DESCRIPTION:\n\
6800 \n\
6801  Sets the number of places after the decimal point in numeric labels. \n\
6802 \n\
6803  Redacted form: plprec(setp, prec)\n\
6804 \n\
6805  This function is used in example 29. \n\
6806 \n\
6807 \n\
6808 \n\
6809 SYNOPSIS:\n\
6810 \n\
6811 plprec(setp, prec)\n\
6812 \n\
6813 ARGUMENTS:\n\
6814 \n\
6815  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
6816  automatically determines the number of places to use after the\n\
6817  decimal point in numeric labels (like those used to label axes). \n\
6818  If setp is 1 then prec sets the number of places. \n\
6819 \n\
6820  prec (PLINT, input) : The number of characters to draw after the\n\
6821  decimal point in numeric labels. \n\
6822 ";
6823 const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
6824 Copy state parameters from the reference stream to the current stream \n\
6825 \n\
6826 DESCRIPTION:\n\
6827 \n\
6828  Copies state parameters from the reference stream to the current\n\
6829  stream. Tell driver interface to map device coordinates unless flags\n\
6830  == 1. \n\
6831 \n\
6832  This function is used for making save files of selected plots (e.g.\n\
6833  from the TK driver). After initializing, you can get a copy of the\n\
6834  current plot to the specified device by switching to this stream and\n\
6835  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
6836  appropriate. The plot buffer must have previously been enabled (done\n\
6837  automatically by some display drivers, such as X). \n\
6838 \n\
6839  Redacted form: plcpstrm(iplsr, flags)\n\
6840 \n\
6841  This function is used in example 1,20. \n\
6842 \n\
6843 \n\
6844 \n\
6845 SYNOPSIS:\n\
6846 \n\
6847 plcpstrm(iplsr, flags)\n\
6848 \n\
6849 ARGUMENTS:\n\
6850 \n\
6851  iplsr (PLINT, input) : Number of reference stream. \n\
6852 \n\
6853  flags (PLBOOL, input) : If flags is set to true the device\n\
6854  coordinates are not copied from the reference to current stream. \n\
6855 ";
6856 const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6857 Plot a glyph at the specified points \n\
6858 \n\
6859 DESCRIPTION:\n\
6860 \n\
6861  Plot a glyph at the specified points. (This function is largely\n\
6862  superseded by plstring which gives access to many[!] more glyphs.)\n\
6863  code=-1 means try to just draw a point. Right now it\'s just a move\n\
6864  and a draw at the same place. Not ideal, since a sufficiently\n\
6865  intelligent output device may optimize it away, or there may be faster\n\
6866  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6867  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6868  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6869  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6870  code <= 127 the corresponding printable ASCII character is plotted. \n\
6871 \n\
6872  Redacted form: plpoin(x, y, code)\n\
6873 \n\
6874  This function is used in examples 1,6,14,29. \n\
6875 \n\
6876 \n\
6877 \n\
6878 SYNOPSIS:\n\
6879 \n\
6880 plpoin(n, x, y, code)\n\
6881 \n\
6882 ARGUMENTS:\n\
6883 \n\
6884  n (PLINT, input) : Number of points in the x and y arrays. \n\
6885 \n\
6886  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
6887  of points. \n\
6888 \n\
6889  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
6890  of points. \n\
6891 \n\
6892  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6893  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6894  each of the n points. \n\
6895 ";
6896 const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
6897 Enter or leave xor mode \n\
6898 \n\
6899 DESCRIPTION:\n\
6900 \n\
6901  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
6902  those drivers (e.g., the xwin driver) that support it. Enables\n\
6903  erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
6904  is not capable of xor operation it returns a status of false. \n\
6905 \n\
6906  Redacted form: plxormod(mode, status)\n\
6907 \n\
6908  This function is used in examples 1,20. \n\
6909 \n\
6910 \n\
6911 \n\
6912 SYNOPSIS:\n\
6913 \n\
6914 plxormod(mode, status)\n\
6915 \n\
6916 ARGUMENTS:\n\
6917 \n\
6918  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
6919  is false means leave xor mode. \n\
6920 \n\
6921  status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
6922  of true (false) means driver is capable (incapable) of xor mode. \n\
6923 ";
6924 const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
6925 Get viewport limits in normalized device coordinates \n\
6926 \n\
6927 DESCRIPTION:\n\
6928 \n\
6929  Get viewport limits in normalized device coordinates. \n\
6930 \n\
6931  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6932 \t Perl/PDL: Not available? \n\
6933 \n\
6934 \n\
6935  This function is used in example 31. \n\
6936 \n\
6937 \n\
6938 \n\
6939 SYNOPSIS:\n\
6940 \n\
6941 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6942 \n\
6943 ARGUMENTS:\n\
6944 \n\
6945  p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
6946  device coordinate in x. \n\
6947 \n\
6948  p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
6949  device coordinate in x. \n\
6950 \n\
6951  p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
6952  device coordinate in y. \n\
6953 \n\
6954  p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
6955  device coordinate in y. \n\
6956 ";
6957 const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
6958 Plot surface mesh \n\
6959 \n\
6960 DESCRIPTION:\n\
6961 \n\
6962  Plots a surface mesh within the environment set up by plw3d. The\n\
6963  surface is defined by the two-dimensional array z[\n\
6964  nx][\n\
6965  ny] , the point z[i][j] being the value of the function at (\n\
6966  x[i], \n\
6967  y[j]) . Note that the points in arrays x and y do not need to be\n\
6968  equally spaced, but must be stored in ascending order. The parameter\n\
6969  opt controls the way in which the surface is displayed. For further\n\
6970  details see the PLplot documentation. \n\
6971 \n\
6972  Redacted form: plmesh(x, y, z, opt)\n\
6973 \n\
6974  This function is used in example 11. \n\
6975 \n\
6976 \n\
6977 \n\
6978 SYNOPSIS:\n\
6979 \n\
6980 plmesh(x, y, z, nx, ny, opt)\n\
6981 \n\
6982 ARGUMENTS:\n\
6983 \n\
6984  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
6985  which the function is evaluated. \n\
6986 \n\
6987  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
6988  which the function is evaluated. \n\
6989 \n\
6990  z (const PLFLT * const *, input) : Pointer to a vectored\n\
6991  two-dimensional array with set of function values. \n\
6992 \n\
6993  nx (PLINT, input) : Number of x values at which function is\n\
6994  evaluated. \n\
6995 \n\
6996  ny (PLINT, input) : Number of y values at which function is\n\
6997  evaluated. \n\
6998 \n\
6999  opt (PLINT, input) : Determines the way in which the surface is\n\
7000  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7001  function of x for each value of y[j] . \n\
7002  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7003  for each value of x[i] . \n\
7004  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7005  at which function is defined. \n\
7006 ";
7007 const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7008 Magnitude colored plot surface mesh with contour \n\
7009 \n\
7010 DESCRIPTION:\n\
7011 \n\
7012  A more powerful form of plmesh: the surface mesh can be colored\n\
7013  accordingly to the current z value being plotted, a contour plot can\n\
7014  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7015  plotted function border and the base XY plane. \n\
7016 \n\
7017  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7018 \n\
7019  This function is used in example 11. \n\
7020 \n\
7021 \n\
7022 \n\
7023 SYNOPSIS:\n\
7024 \n\
7025 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7026 \n\
7027 ARGUMENTS:\n\
7028 \n\
7029  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
7030  which the function is evaluated. \n\
7031 \n\
7032  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
7033  which the function is evaluated. \n\
7034 \n\
7035  z (const PLFLT * const *, input) : Pointer to a vectored\n\
7036  two-dimensional array with set of function values. \n\
7037 \n\
7038  nx (PLINT, input) : Number of x values at which function is\n\
7039  evaluated. \n\
7040 \n\
7041  ny (PLINT, input) : Number of y values at which function is\n\
7042  evaluated. \n\
7043 \n\
7044  opt (PLINT, input) : Determines the way in which the surface is\n\
7045  represented. To specify more than one option just add the options,\n\
7046  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7047  showing z as a function of x for each value of y[j] . \n\
7048  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7049  for each value of x[i] . \n\
7050  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7051  at which function is defined. \n\
7052  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7053  the z value being plotted. The color is used from the current\n\
7054  color map 1. \n\
7055  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7056  using parameters \n\
7057  nlevel and \n\
7058  clevel. \n\
7059  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7060  the borders of the plotted function. \n\
7061 \n\
7062 \n\
7063  clevel (const PLFLT *, input) : Pointer to the array that defines\n\
7064  the contour level spacing. \n\
7065 \n\
7066  nlevel (PLINT, input) : Number of elements in the clevel array. \n\
7067 ";
7068 const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7069 End plotting session for current stream \n\
7070 \n\
7071 DESCRIPTION:\n\
7072 \n\
7073  Ends a plotting session for the current output stream only. See\n\
7074  plsstrm for more info. \n\
7075 \n\
7076  Redacted form: plend1()\n\
7077 \n\
7078  This function is used in examples 1,20. \n\
7079 \n\
7080 \n\
7081 \n\
7082 SYNOPSIS:\n\
7083 \n\
7084 plend1()\n\
7085 ";
7086 const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7087 Get y axis parameters \n\
7088 \n\
7089 DESCRIPTION:\n\
7090 \n\
7091  Identical to plgxax, except that arguments are flags for y axis. See\n\
7092  the description of plgxax for more detail. \n\
7093 \n\
7094  Redacted form: plgyax(p_digmax, p_digits)\n\
7095 \n\
7096  This function is used in example 31. \n\
7097 \n\
7098 \n\
7099 \n\
7100 SYNOPSIS:\n\
7101 \n\
7102 plgyax(p_digmax, p_digits)\n\
7103 \n\
7104 ARGUMENTS:\n\
7105 \n\
7106  p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7107  number of digits for the y axis. If nonzero, the printed label\n\
7108  has been switched to a floating point representation when the\n\
7109  number of digits exceeds p_digmax. \n\
7110 \n\
7111  p_digits (PLINT *, output) : Pointer to variable with the actual\n\
7112  number of digits for the numeric labels (y axis) from the last\n\
7113  plot. \n\
7114 ";
7115 const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7116 Set plot orientation \n\
7117 \n\
7118 DESCRIPTION:\n\
7119 \n\
7120  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7121  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7122  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7123  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7124  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7125  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7126  not called the default value of rot is 0. \n\
7127 \n\
7128  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7129  probably want to change the aspect ratio to a value suitable for the\n\
7130  plot orientation using a call to plsdidev or the command-line options\n\
7131  -a or -freeaspect.\tFor more documentation of those options see the\n\
7132  PLplot documentation. Such command-line options can be set internally\n\
7133  using plsetopt or set directly using the command line and parsed using\n\
7134  a call to plparseopts. \n\
7135 \n\
7136  Redacted form: plsdiori(rot)\n\
7137 \n\
7138  This function is not used in any examples. \n\
7139 \n\
7140 \n\
7141 \n\
7142 SYNOPSIS:\n\
7143 \n\
7144 plsdiori(rot)\n\
7145 \n\
7146 ARGUMENTS:\n\
7147 \n\
7148  rot (PLFLT, input) : Plot orientation parameter. \n\
7149 ";
7150 const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7151 Plot a histogram from unbinned data \n\
7152 \n\
7153 DESCRIPTION:\n\
7154 \n\
7155  Plots a histogram from n data points stored in the array data. This\n\
7156  routine bins the data into nbin bins equally spaced between datmin and\n\
7157  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7158  opt allows, among other things, the histogram either to be plotted in\n\
7159  an existing window or causes plhist to call plenv with suitable limits\n\
7160  before plotting the histogram. \n\
7161 \n\
7162  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7163 \n\
7164  This function is used in example 5. \n\
7165 \n\
7166 \n\
7167 \n\
7168 SYNOPSIS:\n\
7169 \n\
7170 plhist(n, data, datmin, datmax, nbin, opt)\n\
7171 \n\
7172 ARGUMENTS:\n\
7173 \n\
7174  n (PLINT, input) : Number of data points. \n\
7175 \n\
7176  data (const PLFLT *, input) : Pointer to array with values of the n\n\
7177  data points. \n\
7178 \n\
7179  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
7180 \n\
7181  datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
7182 \n\
7183  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7184  divide the interval xmin to xmax. \n\
7185 \n\
7186  opt (PLINT, input) : Is a combination of several flags:\n\
7187  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7188  the histogram data, the outer bins are expanded to fill up the\n\
7189  entire x-axis, data outside the given extremes are assigned to the\n\
7190  outer bins and bins of zero height are simply drawn. \n\
7191  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7192  to fit the histogram data, without this flag, plenv is called\n\
7193  to set the world coordinates. \n\
7194  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7195  extremes are not taken into account. This option should\n\
7196  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7197  properly present the data. \n\
7198  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7199  size as the ones inside. \n\
7200  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7201  (there is a gap for such bins). \n\
7202 ";
7203 const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7204 End plotting session \n\
7205 \n\
7206 DESCRIPTION:\n\
7207 \n\
7208  Ends a plotting session, tidies up all the output files, switches\n\
7209  interactive devices back into text mode and frees up any memory that\n\
7210  was allocated. Must be called before end of program. \n\
7211 \n\
7212  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7213  wait state after a call to plend or other functions which trigger the\n\
7214  end of a plot page. To avoid this, use the plspause function. \n\
7215 \n\
7216  Redacted form: plend()\n\
7217 \n\
7218  This function is used in all of the examples. \n\
7219 \n\
7220 \n\
7221 \n\
7222 SYNOPSIS:\n\
7223 \n\
7224 plend()\n\
7225 ";
7226 const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7227 Plot shaded 3-d surface plot \n\
7228 \n\
7229 DESCRIPTION:\n\
7230 \n\
7231  Plots a three dimensional shaded surface plot within the environment\n\
7232  set up by plw3d. The surface is defined by the two-dimensional array\n\
7233  z[\n\
7234  nx][\n\
7235  ny] , the point z[i][j] being the value of the function at (\n\
7236  x[i], \n\
7237  y[j]) . Note that the points in arrays x and y do not need to be\n\
7238  equally spaced, but must be stored in ascending order. For further\n\
7239  details see the PLplot documentation. \n\
7240 \n\
7241  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7242 \n\
7243  This function is not used in any examples. \n\
7244 \n\
7245 \n\
7246 \n\
7247 SYNOPSIS:\n\
7248 \n\
7249 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7250 \n\
7251 ARGUMENTS:\n\
7252 \n\
7253  x (const PLFLT *, input) : Pointer to set of x coordinate values at\n\
7254  which the function is evaluated. \n\
7255 \n\
7256  y (const PLFLT *, input) : Pointer to set of y coordinate values at\n\
7257  which the function is evaluated. \n\
7258 \n\
7259  z (const PLFLT * const *, input) : Pointer to a vectored\n\
7260  two-dimensional array with set of function values. \n\
7261 \n\
7262  nx (PLINT, input) : Number of x values at which function is\n\
7263  evaluated. \n\
7264 \n\
7265  ny (PLINT, input) : Number of y values at which function is\n\
7266  evaluated. \n\
7267 \n\
7268  opt (PLINT, input) : Determines the way in which the surface is\n\
7269  represented. To specify more than one option just add the options,\n\
7270  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7271  connecting points at which function is defined. \n\
7272  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7273  using parameters \n\
7274  nlevel and \n\
7275  clevel. \n\
7276  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7277  using parameters \n\
7278  nlevel and \n\
7279  clevel. \n\
7280  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7281  the borders of the plotted function. \n\
7282  opt=MAG_COLOR : the surface is colored according to the value\n\
7283  of Z; if MAG_COLOR is not used, then the default the surface\n\
7284  is colored according to the intensity of the reflected light\n\
7285  in the surface from a light source whose position is set using\n\
7286  pllightsource. \n\
7287 \n\
7288 \n\
7289  clevel (const PLFLT *, input) : Pointer to the array that defines\n\
7290  the contour level spacing. \n\
7291 \n\
7292  nlevel (PLINT, input) : Number of elements in the clevel array. \n\
7293 ";
7294 const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7295 Set device-compression level \n\
7296 \n\
7297 DESCRIPTION:\n\
7298 \n\
7299  Set device-compression level. Only used for drivers that provide\n\
7300  compression. This function, if used, should be invoked before a call\n\
7301  to plinit. \n\
7302 \n\
7303  Redacted form: plscompression(compression)\n\
7304 \n\
7305  This function is used in example 31. \n\
7306 \n\
7307 \n\
7308 \n\
7309 SYNOPSIS:\n\
7310 \n\
7311 plscompression(compression)\n\
7312 \n\
7313 ARGUMENTS:\n\
7314 \n\
7315  compression (PLINT, input) : The desired compression level. This is\n\
7316  a device-dependent value. Currently only the jpeg and png devices\n\
7317  use these values. For jpeg value is the jpeg quality which should\n\
7318  normally be in the range 0-95. Higher values denote higher quality\n\
7319  and hence larger image sizes. For png values are in the range -1\n\
7320  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7321  A value of -1 denotes the default zlib compression level. Values\n\
7322  in the range 10-99 are divided by 10 and then used as the zlib\n\
7323  compression level. Higher compression levels correspond to greater\n\
7324  compression and small file sizes at the expense of more\n\
7325  computation. \n\
7326 ";
7327 const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7328 Get the current device-compression setting \n\
7329 \n\
7330 DESCRIPTION:\n\
7331 \n\
7332  Get the current device-compression setting. This parameter is only\n\
7333  used for drivers that provide compression. \n\
7334 \n\
7335  Redacted form: plgcompression(compression)\n\
7336 \n\
7337  This function is used in example 31. \n\
7338 \n\
7339 \n\
7340 \n\
7341 SYNOPSIS:\n\
7342 \n\
7343 plgcompression(compression)\n\
7344 \n\
7345 ARGUMENTS:\n\
7346 \n\
7347  compression (PLINT *, output) : Pointer to a variable to be filled\n\
7348  with the current device-compression setting. \n\
7349 ";
7350 const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7351 Advance the (sub-)page\n\
7352 \n\
7353 DESCRIPTION:\n\
7354 \n\
7355  Advances to the next subpage if sub=0, performing a page advance if\n\
7356  there are no remaining subpages on the current page. If subpages\n\
7357  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7358  PLplot switches to the specified subpage. Note that this allows you\n\
7359  to overwrite a plot on the specified subpage; if this is not what you\n\
7360  intended, use pleop followed by plbop to first advance the page. This\n\
7361  routine is called automatically (with page=0) by plenv, but if plenv\n\
7362  is not used, pladv must be called after initializing PLplot but before\n\
7363  defining the viewport. \n\
7364 \n\
7365  Redacted form: pladv(page)\n\
7366 \n\
7367  This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
7368 \n\
7369 \n\
7370 \n\
7371 SYNOPSIS:\n\
7372 \n\
7373 pladv(page)\n\
7374 \n\
7375 ARGUMENTS:\n\
7376 \n\
7377  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7378  in the top left corner and increasing along the rows) to which to\n\
7379  advance. Set to zero to advance to the next subpage (or to the\n\
7380  next page if subpages are not being used). \n\
7381 ";
7382 const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7383 Set parameters of contour labelling other than format of numerical label\n\
7384 \n\
7385 DESCRIPTION:\n\
7386 \n\
7387  Set parameters of contour labelling other than those handled by\n\
7388  pl_setcontlabelformat. \n\
7389 \n\
7390  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7391 \n\
7392  This function is used in example 9. \n\
7393 \n\
7394 \n\
7395 \n\
7396 SYNOPSIS:\n\
7397 \n\
7398 pl_setcontlabelparam(offset, size, spacing, active)\n\
7399 \n\
7400 ARGUMENTS:\n\
7401 \n\
7402  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7403  to 0.0, labels are printed on the lines). Default value is 0.006. \n\
7404 \n\
7405  size (PLFLT, input) : Font height for contour labels (normalized). \n\
7406  Default value is 0.3. \n\
7407 \n\
7408  spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
7409  Default value is 0.1. \n\
7410 \n\
7411  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7412  contour labels on. Default is off (0). \n\
7413 ";
7414 const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7415 Set family, style and weight of the current font \n\
7416 \n\
7417 DESCRIPTION:\n\
7418 \n\
7419  Sets the current font. See the PLplot documentation for more\n\
7420  information on font selection. \n\
7421 \n\
7422  Redacted form: plsfont(family, style, weight)\n\
7423 \n\
7424  This function is used in example 23. \n\
7425 \n\
7426 \n\
7427 \n\
7428 SYNOPSIS:\n\
7429 \n\
7430 plsfont(family, style, weight)\n\
7431 \n\
7432 ARGUMENTS:\n\
7433 \n\
7434  family (PLINT, input) : Font family to select for the current font.\n\
7435  The available values are given by the PL_FCI_* constants in\n\
7436  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7437  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7438  signifies that the font family should not be altered. \n\
7439 \n\
7440  style (PLINT, input) : Font style to select for the current font.\n\
7441  The available values are given by the PL_FCI_* constants in\n\
7442  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7443  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7444  should not be altered. \n\
7445 \n\
7446  weight (PLINT, input) : Font weight to select for the current font.\n\
7447  The available values are given by the PL_FCI_* constants in\n\
7448  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7449  negative value signifies that the font weight should not be\n\
7450  altered. \n\
7451 ";
7452 const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7453 Sets the 3D position of the light source \n\
7454 \n\
7455 DESCRIPTION:\n\
7456 \n\
7457  Sets the 3D position of the light source for use with plsurf3d. \n\
7458 \n\
7459  Redacted form: pllightsource(x, y, z)\n\
7460 \n\
7461  This function is used in example 8. \n\
7462 \n\
7463 \n\
7464 \n\
7465 SYNOPSIS:\n\
7466 \n\
7467 pllightsource(x, y, z)\n\
7468 \n\
7469 ARGUMENTS:\n\
7470 \n\
7471  x (PLFLT, input) : X-coordinate of the light source. \n\
7472 \n\
7473  y (PLFLT, input) : Y-coordinate of the light source. \n\
7474 \n\
7475  z (PLFLT, input) : Z-coordinate of the light source. \n\
7476 ";
7477 const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7478 Draw a line \n\
7479 \n\
7480 DESCRIPTION:\n\
7481 \n\
7482  Draws line defined by n points in x and y. \n\
7483 \n\
7484  Redacted form: plline(x, y)\n\
7485 \n\
7486  This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
7487 \n\
7488 \n\
7489 \n\
7490 SYNOPSIS:\n\
7491 \n\
7492 plline(n, x, y)\n\
7493 \n\
7494 ARGUMENTS:\n\
7495 \n\
7496  n (PLINT, input) : Number of points defining line. \n\
7497 \n\
7498  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
7499  points. \n\
7500 \n\
7501  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
7502  points. \n\
7503 ";
7504 const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7505 Set pen width \n\
7506 \n\
7507 DESCRIPTION:\n\
7508 \n\
7509  Sets the pen width. \n\
7510 \n\
7511  Redacted form: plwidth(width)\n\
7512 \n\
7513  This function is used in examples 1,2. \n\
7514 \n\
7515 \n\
7516 \n\
7517 SYNOPSIS:\n\
7518 \n\
7519 plwidth(width)\n\
7520 \n\
7521 ARGUMENTS:\n\
7522 \n\
7523  width (PLFLT, input) : The desired pen width. If width is negative\n\
7524  or the same as the previous value no action is taken. width = 0. \n\
7525  should be interpreted as as the minimum valid pen width for the\n\
7526  device. The interpretation of positive width values is also\n\
7527  device dependent. \n\
7528 ";
7529 const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7530 Draw linear gradient inside polygon \n\
7531 \n\
7532 DESCRIPTION:\n\
7533 \n\
7534  Draw a linear gradient using colour map 1 inside the polygon defined\n\
7535  by the n points (\n\
7536  x[i], \n\
7537  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7538  polygon coordinates and the gradient angle are all expressed in world\n\
7539  coordinates. The angle from the x axis for both the rotated\n\
7540  coordinate system and the gradient vector is specified by angle. The\n\
7541  magnitude of the gradient vector is the difference between the maximum\n\
7542  and minimum values of x for the vertices in the rotated coordinate\n\
7543  system. The origin of the gradient vector can be interpreted as being\n\
7544  anywhere on the line corresponding to the minimum x value for the\n\
7545  vertices in the rotated coordinate system.\tThe distance along the\n\
7546  gradient vector is linearly transformed to the independent variable of\n\
7547  colour map 1 which ranges from 0. at the tail of the gradient vector\n\
7548  to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
7549  colour corresponding to the independent variable of colour map 1. For\n\
7550  more information about colour map 1 (see the PLplot documentation). \n\
7551 \n\
7552  Redacted form: plgradient(x,y,angle)\n\
7553 \n\
7554  This function is used in examples 25,30. \n\
7555 \n\
7556 \n\
7557 \n\
7558 SYNOPSIS:\n\
7559 \n\
7560 plgradient(n, x, y, angle)\n\
7561 \n\
7562 ARGUMENTS:\n\
7563 \n\
7564  n (PLINT, input) : Number of vertices in polygon. \n\
7565 \n\
7566  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
7567  vertices. \n\
7568 \n\
7569  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
7570  vertices. \n\
7571 \n\
7572  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
7573  axis. \n\
7574 ";
7575 const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
7576 Flushes the output stream \n\
7577 \n\
7578 DESCRIPTION:\n\
7579 \n\
7580  Flushes the output stream. Use sparingly, if at all. \n\
7581 \n\
7582  Redacted form: plflush()\n\
7583 \n\
7584  This function is used in examples 1,14. \n\
7585 \n\
7586 \n\
7587 \n\
7588 SYNOPSIS:\n\
7589 \n\
7590 plflush()\n\
7591 ";
7592 const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7593 Get plot orientation \n\
7594 \n\
7595 DESCRIPTION:\n\
7596 \n\
7597  Get plot orientation parameter which is multiplied by 90 degrees to\n\
7598  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7599  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7600  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7601  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7602  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7603  not been called the default value pointed to by p_rot will be 0. \n\
7604 \n\
7605  Redacted form: plgdiori(p_rot)\n\
7606 \n\
7607  This function is not used in any examples. \n\
7608 \n\
7609 \n\
7610 \n\
7611 SYNOPSIS:\n\
7612 \n\
7613 plgdiori(p_rot)\n\
7614 \n\
7615 ARGUMENTS:\n\
7616 \n\
7617  p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
7618 ";
7619 const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
7620 Set x axis parameters \n\
7621 \n\
7622 DESCRIPTION:\n\
7623 \n\
7624  Sets values of the digmax and digits flags for the x axis.\tSee the\n\
7625  PLplot documentation for more information. \n\
7626 \n\
7627  Redacted form: plsxax(digmax, digits)\n\
7628 \n\
7629  This function is used in example 31. \n\
7630 \n\
7631 \n\
7632 \n\
7633 SYNOPSIS:\n\
7634 \n\
7635 plsxax(digmax, digits)\n\
7636 \n\
7637 ARGUMENTS:\n\
7638 \n\
7639  digmax (PLINT, input) : Variable to set the maximum number of\n\
7640  digits for the x axis. If nonzero, the printed label will be\n\
7641  switched to a floating point representation when the number of\n\
7642  digits exceeds digmax. \n\
7643 \n\
7644  digits (PLINT, input) : Field digits value. Currently, changing\n\
7645  its value here has no effect since it is set only by plbox or\n\
7646  plbox3. However, the user may obtain its value after a call to\n\
7647  either of these functions by calling plgxax. \n\
7648 ";
7649 const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
7650 Get viewport limits in world coordinates \n\
7651 \n\
7652 DESCRIPTION:\n\
7653 \n\
7654  Get viewport limits in world coordinates. \n\
7655 \n\
7656  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7657 \t Perl/PDL: Not available? \n\
7658 \n\
7659 \n\
7660  This function is used in example 31. \n\
7661 \n\
7662 \n\
7663 \n\
7664 SYNOPSIS:\n\
7665 \n\
7666 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7667 \n\
7668 ARGUMENTS:\n\
7669 \n\
7670  p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
7671  coordinate in x. \n\
7672 \n\
7673  p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
7674  coordinate in x. \n\
7675 \n\
7676  p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
7677  coordinate in y. \n\
7678 \n\
7679  p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
7680  coordinate in y. \n\
7681 ";
7682 const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
7683 Shade regions on the basis of value \n\
7684 \n\
7685 DESCRIPTION:\n\
7686 \n\
7687  Shade regions on the basis of value. This is the high-level routine\n\
7688  for making continuous color shaded plots with cmap1 while plshade (or\n\
7689  plshade1) are used for individual shaded regions using either cmap0 or\n\
7690  cmap1. examples/c/x16c.c shows a number of examples for using this\n\
7691  function. See the following discussion of the arguments and the PLplot\n\
7692  documentation for more information. \n\
7693 \n\
7694  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
7695  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
7696  pltr_data)\n\
7697 \t Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n\
7698  fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n\
7699  pltr_data)\n\
7700 \n\
7701 \n\
7702  This function is used in examples 16,21. \n\
7703 \n\
7704 \n\
7705 \n\
7706 SYNOPSIS:\n\
7707 \n\
7708 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
7709 \n\
7710 ARGUMENTS:\n\
7711 \n\
7712  a (const PLFLT * const *, input) : Contains ** pointer to array to\n\
7713  be plotted. The array must have been declared as PLFLT a[nx][ny]. \n\
7714 \n\
7715  nx (PLINT, input) : First dimension of array \"a\". \n\
7716 \n\
7717  ny (PLINT, input) : Second dimension of array \"a\". \n\
7718 \n\
7719  defined (PLINT (*) (PLFLT, PLFLT), input) : User function\n\
7720  specifying regions excluded from the shading plot. This function\n\
7721  accepts x and y coordinates as input arguments and must return 0\n\
7722  if the point is in the excluded region or 1 otherwise. This\n\
7723  argument can be NULL if all the values are valid. \n\
7724 \n\
7725  xmin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7726  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7727  at (xmax,ymin) and so on. \n\
7728 \n\
7729  xmax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7730  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7731  at (xmax,ymin) and so on. \n\
7732 \n\
7733  ymin (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7734  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7735  at (xmax,ymin) and so on. \n\
7736 \n\
7737  ymax (PLFLT, input) : Defines the \"grid\" coordinates. The data\n\
7738  a[0][0] has a position of (xmin,ymin), a[nx-1][0] has a position\n\
7739  at (xmax,ymin) and so on. \n\
7740 \n\
7741  clevel (const PLFLT *, input) : Pointer to array containing the\n\
7742  data levels corresponding to the edges of each shaded region that\n\
7743  will be plotted by this function. To work properly the levels\n\
7744  should be monotonic. \n\
7745 \n\
7746  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
7747  of shade edge values in clevel). \n\
7748 \n\
7749  fill_width (PLFLT, input) : Defines line width used by the fill\n\
7750  pattern. \n\
7751 \n\
7752  cont_color (PLINT, input) : Defines pen color used for contours\n\
7753  defining edges of shaded regions. The pen color is only temporary\n\
7754  set for the contour drawing. Set this value to zero or less if no\n\
7755  shade edge contours are wanted. \n\
7756 \n\
7757  cont_width (PLFLT, input) : Defines line width used for contours\n\
7758  defining edges of shaded regions. This value may not be honored\n\
7759  by all drivers. The pen width is only temporary set for the\n\
7760  contour drawing. Set this value to zero or less if no shade edge\n\
7761  contours are wanted. \n\
7762 \n\
7763  fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
7764  Routine used to fill the region. Use plfill. Future version of\n\
7765  PLplot may have other fill routines. \n\
7766 \n\
7767  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
7768  map to rectangles after coordinate transformation with pltrl. \n\
7769  Otherwise, set rectangular to false. If rectangular is set to\n\
7770  true, plshade tries to save time by filling large rectangles. \n\
7771  This optimization fails if the coordinate transformation distorts\n\
7772  the shape of rectangles. For example a plot in polar coordinates\n\
7773  has to have rectangular set to false. \n\
7774 \n\
7775  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
7776  Pointer to function that defines transformation between indices\n\
7777  in array z and the world coordinates (C only). Transformation\n\
7778  functions are provided in the PLplot library: pltr0 for identity\n\
7779  mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
7780  defined by one- and two-dimensional arrays. In addition,\n\
7781  user-supplied routines for the transformation can be used as well.\n\
7782  Examples of all of these approaches are given in the PLplot\n\
7783  documentation. The transformation function should have the form\n\
7784  given by any of pltr0, pltr1, or pltr2. \n\
7785 \n\
7786  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
7787  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
7788  externally supplied. \n\
7789 ";
7790 const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
7791 Plot color bar for image, shade or gradient plots \n\
7792 \n\
7793 DESCRIPTION:\n\
7794 \n\
7795  Routine for creating a continuous color bar for image, shade, or\n\
7796  gradient plots. (See pllegend for similar functionality for creating\n\
7797  legends with discrete elements). The arguments of plcolorbar provide\n\
7798  control over the location and size of the color bar as well as the\n\
7799  location and characteristics of the elements (most of which are\n\
7800  optional) within that color bar. The resulting color bar is clipped\n\
7801  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
7802  system used for some of the parameters is defined in the documentation\n\
7803  of the position parameter.) \n\
7804 \n\
7805  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
7806  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
7807  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
7808  labels, axis_opts, ticks, sub_ticks, values)\n\
7809 \n\
7810  This function is used in examples 16 and 33. \n\
7811 \n\
7812 \n\
7813 \n\
7814 SYNOPSIS:\n\
7815 \n\
7816 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\
7817 \n\
7818 ARGUMENTS:\n\
7819 \n\
7820  p_colorbar_width (PLFLT *, output) : Pointer to a location which\n\
7821  contains (after the call) the labelled and decorated color bar\n\
7822  width in adopted coordinates. \n\
7823 \n\
7824  p_colorbar_height (PLFLT *, output) : Pointer to a location which\n\
7825  contains (after the call) the labelled and decorated color bar\n\
7826  height in adopted coordinates. \n\
7827 \n\
7828  opt (PLINT, input) : opt contains bits controlling the overall\n\
7829  color bar. The orientation (direction of the maximum value) of\n\
7830  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
7831  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
7832  specified, the default orientation is toward the top if the\n\
7833  colorbar is placed on the left or right of the viewport or toward\n\
7834  the right if the colorbar is placed on the top or bottom of the\n\
7835  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
7836  (semi-transparent) background for the color bar. If the\n\
7837  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
7838  color bar. The type of color bar must be specified with one of\n\
7839  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
7840  more than one of those bits is set only the first one in the above\n\
7841  list is honored. The position of the (optional) label/title can be\n\
7842  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
7843  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
7844  will be drawn. If more than one of this list of bits is specified,\n\
7845  only the first one on the list is honored. End-caps for the color\n\
7846  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
7847  If a particular color bar cap option is not specified then no cap\n\
7848  will be drawn for that end. As a special case for\n\
7849  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
7850  specified. If this option is provided then any tick marks and tick\n\
7851  labels will be placed at the breaks between shaded segments. TODO:\n\
7852  This should be expanded to support custom placement of tick marks\n\
7853  and tick labels at custom value locations for any color bar type. \n\
7854 \n\
7855  position (PLINT, input) : position contains bits which control the\n\
7856  overall position of the color bar and the definition of the\n\
7857  adopted coordinates used for positions just like what is done for\n\
7858  the position argument for pllegend. However, note that the\n\
7859  defaults for the position bits (see below) are different than the\n\
7860  pllegend case. The combination of the PL_POSITION_LEFT,\n\
7861  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
7862  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
7863  the 16 possible standard positions (the 4 corners and centers of\n\
7864  the 4 sides for both the inside and outside cases) of the color\n\
7865  bar relative to the adopted coordinate system. The corner\n\
7866  positions are specified by the appropriate combination of two of\n\
7867  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
7868  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
7869  value of one of those bits. The adopted coordinates are\n\
7870  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
7871  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
7872  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
7873  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
7874  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
7875  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
7876  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
7877  PL_POSITION_VIEWPORT. \n\
7878 \n\
7879  x (PLFLT, input) : X offset of the color bar position in adopted\n\
7880  coordinates from the specified standard position of the color bar.\n\
7881  For positive x, the direction of motion away from the standard\n\
7882  position is inward/outward from the standard corner positions or\n\
7883  standard left or right positions if the\n\
7884  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
7885  For the standard top or bottom positions, the direction of motion\n\
7886  is toward positive X. \n\
7887 \n\
7888  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
7889  coordinates from the specified standard position of the color bar.\n\
7890  For positive y, the direction of motion away from the standard\n\
7891  position is inward/outward from the standard corner positions or\n\
7892  standard top or bottom positions if the\n\
7893  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
7894  For the standard left or right positions, the direction of motion\n\
7895  is toward positive Y. \n\
7896 \n\
7897  x_length (PLFLT, input) : Length of the body of the color bar in\n\
7898  the X direction in adopted coordinates. \n\
7899 \n\
7900  y_length (PLFLT, input) : Length of the body of the color bar in\n\
7901  the Y direction in adopted coordinates. \n\
7902 \n\
7903  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
7904  color bar (PL_COLORBAR_BACKGROUND). \n\
7905 \n\
7906  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
7907  for the color bar (PL_COLORBAR_BOUNDING_BOX). \n\
7908 \n\
7909  bb_style (PLINT, input) : The pllsty style number for the\n\
7910  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND). \n\
7911 \n\
7912  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
7913  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW). \n\
7914 \n\
7915  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
7916  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH). \n\
7917 \n\
7918  cont_color (PLINT, input) : The cmap0 contour color for\n\
7919  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
7920  it will be interpreted according to the design of plshades. \n\
7921 \n\
7922  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
7923  plots. This is passed directly to plshades, so it will be\n\
7924  interpreted according to the design of plshades. \n\
7925 \n\
7926  n_labels (PLINT, input) : Number of labels to place around the\n\
7927  color bar. \n\
7928 \n\
7929  label_opts (const PLINT *, input) : Options for each of \n\
7930  n_labels labels. \n\
7931 \n\
7932  labels (const char * const *, input) : n_labels text labels for the\n\
7933  color bar. No label is drawn if no label position is specified\n\
7934  with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
7935  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
7936  corresponding label_opts field. \n\
7937 \n\
7938  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
7939  value must be greater than 0. It is typically 1 (numerical axis\n\
7940  labels are provided for one of the long edges of the color bar),\n\
7941  but it can be larger if multiple numerical axis labels for the\n\
7942  long edges of the color bar are desired. \n\
7943 \n\
7944  axis_opts (const char * const *, input) : An array of n_axes axis\n\
7945  options (interpreted as for plbox) for the color bar\'s axis\n\
7946  definitions. \n\
7947 \n\
7948  ticks (const PLFLT *, input) : An array of n_axes values of the\n\
7949  spacing of the major tick marks (interpreted as for plbox) for the\n\
7950  color bar\'s axis definitions. \n\
7951 \n\
7952  sub_ticks (const PLINT *, input) : An array of n_axes values of the\n\
7953  number of subticks (interpreted as for plbox) for the color bar\'s\n\
7954  axis definitions. \n\
7955 \n\
7956  n_values (const PLINT *, input) : An array containing the number of\n\
7957  elements in each of the n_axes rows of the two-dimensional values\n\
7958  array. \n\
7959 \n\
7960  values (const PLFLT * const *, input) : A two-dimensional array\n\
7961  containing the numeric values for the data range represented by\n\
7962  the color bar. For a row index of i_axis (where 0 < i_axis <\n\
7963  n_axes), the number of elements in the row is specified by\n\
7964  n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT\n\
7965  the number of elements is 2, and the corresponding row elements of\n\
7966  the values array are the minimum and maximum value represented by\n\
7967  the colorbar. For PL_COLORBAR_SHADE, the number and values of the\n\
7968  elements of a row of the values array is interpreted the same as\n\
7969  the nlevel and clevel arguments of plshades. \n\
7970 ";
7971 const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
7972 Get current subpage parameters \n\
7973 \n\
7974 DESCRIPTION:\n\
7975 \n\
7976  Gets the size of the current subpage in millimeters measured from the\n\
7977  bottom left hand corner of the output device page or screen. Can be\n\
7978  used in conjunction with plsvpa for setting the size of a viewport in\n\
7979  absolute coordinates (millimeters). \n\
7980 \n\
7981  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
7982 \n\
7983  This function is used in example 23. \n\
7984 \n\
7985 \n\
7986 \n\
7987 SYNOPSIS:\n\
7988 \n\
7989 plgspa(xmin, xmax, ymin, ymax)\n\
7990 \n\
7991 ARGUMENTS:\n\
7992 \n\
7993  xmin (PLFLT *, output) : Pointer to variable with position of left\n\
7994  hand edge of subpage in millimeters. \n\
7995 \n\
7996  xmax (PLFLT *, output) : Pointer to variable with position of right\n\
7997  hand edge of subpage in millimeters. \n\
7998 \n\
7999  ymin (PLFLT *, output) : Pointer to variable with position of\n\
8000  bottom edge of subpage in millimeters. \n\
8001 \n\
8002  ymax (PLFLT *, output) : Pointer to variable with position of top\n\
8003  edge of subpage in millimeters. \n\
8004 ";
8005 const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8006 Shade individual region on the basis of value \n\
8007 \n\
8008 DESCRIPTION:\n\
8009 \n\
8010  Shade individual region on the basis of value. Use plshades if you\n\
8011  want to shade a number of regions using continuous colors. plshade is\n\
8012  identical to plshade1 except for the type of the first parameter. See\n\
8013  plshade1 for further discussion. \n\
8014 \n\
8015  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8016  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8017  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8018 \t Perl/PDL: Not available? \n\
8019 \n\
8020 \n\
8021  This function is used in example 15. \n\
8022 \n\
8023 \n\
8024 \n\
8025 SYNOPSIS:\n\
8026 \n\
8027 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\
8028 \n\
8029 ARGUMENTS:\n\
8030 \n\
8031  a (const PLFLT * const *, input) : \n\
8032 \n\
8033  nx (PLINT, input) : \n\
8034 \n\
8035  ny (PLINT, input) : \n\
8036 \n\
8037  defined (PLINT (*) (PLFLT, PLFLT), input) : \n\
8038 \n\
8039  xmin (PLFLT, input) : \n\
8040 \n\
8041  xmax (PLFLT, input) : \n\
8042 \n\
8043  ymin (PLFLT, input) : \n\
8044 \n\
8045  ymax (PLFLT, input) : \n\
8046 \n\
8047  shade_min (PLFLT, input) : \n\
8048 \n\
8049  shade_max (PLFLT, input) : \n\
8050 \n\
8051  sh_cmap (PLINT, input) : \n\
8052 \n\
8053  sh_color (PLFLT, input) : \n\
8054 \n\
8055  sh_width (PLFLT, input) : \n\
8056 \n\
8057  min_color (PLINT, input) : \n\
8058 \n\
8059  min_width (PLFLT, input) : \n\
8060 \n\
8061  max_color (PLINT, input) : \n\
8062 \n\
8063  max_width (PLFLT, input) : \n\
8064 \n\
8065  fill (void (*) (PLINT, const PLFLT *, const PLFLT *), input) : \n\
8066 \n\
8067  rectangular (PLBOOL, input) : \n\
8068 \n\
8069  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8070 \n\
8071  pltr_data (PLPointer, input) : \n\
8072 ";
8073 const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8074 Calculate world coordinates and corresponding window index from relative device coordinates \n\
8075 \n\
8076 DESCRIPTION:\n\
8077 \n\
8078  Calculate world coordinates, wx and wy, and corresponding window index\n\
8079  from relative device coordinates, rx and ry. \n\
8080 \n\
8081  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8082 \t Perl/PDL: Not available? \n\
8083 \n\
8084 \n\
8085  This function is used in example 31. \n\
8086 \n\
8087 \n\
8088 \n\
8089 SYNOPSIS:\n\
8090 \n\
8091 plcalc_world(rx, ry, wx, wy, window)\n\
8092 \n\
8093 ARGUMENTS:\n\
8094 \n\
8095  rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
8096  0. to 1.) for the x coordinate. \n\
8097 \n\
8098  ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
8099  0. to 1.) for the y coordinate. \n\
8100 \n\
8101  wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
8102  x corresponding to the relative device coordinates rx and ry. \n\
8103 \n\
8104  wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
8105  y corresponding to the relative device coordinates rx and ry. \n\
8106 \n\
8107  window (PLINT *, output) : Pointer to the returned last defined\n\
8108  window index that corresponds to the input relative device\n\
8109  coordinates (and the returned world coordinates). To give some\n\
8110  background on the window index, for each page the initial window\n\
8111  index is set to zero, and each time plwind is called within the\n\
8112  page, world and device coordinates are stored for the window and\n\
8113  the window index is incremented. Thus, for a simple page layout\n\
8114  with non-overlapping viewports and one window per viewport, window\n\
8115  corresponds to the viewport index (in the order which the\n\
8116  viewport/windows were created) of the only viewport/window\n\
8117  corresponding to rx and ry. However, for more complicated layouts\n\
8118  with potentially overlapping viewports and possibly more than one\n\
8119  window (set of world coordinates) per viewport, window and the\n\
8120  corresponding output world coordinates corresponds to the last\n\
8121  window created that fulfills the criterion that the relative\n\
8122  device coordinates are inside it. Finally, in all cases where the\n\
8123  input relative device coordinates are not inside any\n\
8124  viewport/window, then window is set to -1. \n\
8125 ";
8126 const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8127 Draw a box with axes, etc, in 3-d \n\
8128 \n\
8129 DESCRIPTION:\n\
8130 \n\
8131  Draws axes, numeric and text labels for a three-dimensional surface\n\
8132  plot. For a more complete description of three-dimensional plotting\n\
8133  see the PLplot documentation. \n\
8134 \n\
8135  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8136  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8137 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
8138  xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
8139 \n\
8140 \n\
8141  This function is used in examples 8,11,18,21. \n\
8142 \n\
8143 \n\
8144 \n\
8145 SYNOPSIS:\n\
8146 \n\
8147 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8148 \n\
8149 ARGUMENTS:\n\
8150 \n\
8151  xopt (const char *, input) : Pointer to character string specifying\n\
8152  options for the x axis. The string can include any combination of\n\
8153  the following letters (upper or lower case) in any order: b: Draws\n\
8154  axis at base, at height z=\n\
8155  zmin where zmin is defined by call to plw3d. This character must be\n\
8156  specified in order to use any of the other options. \n\
8157  f: Always use fixed point numeric labels. \n\
8158  i: Inverts tick marks, so they are drawn downwards, rather\n\
8159  than upwards. \n\
8160  l: Labels axis logarithmically. This only affects the labels,\n\
8161  not the data, and so it is necessary to compute the logarithms\n\
8162  of data points before passing them to any of the drawing\n\
8163  routines. \n\
8164  n: Writes numeric labels at major tick intervals. \n\
8165  o: Use custom labelling function to generate axis label text. \n\
8166  The custom labelling function can be defined with the\n\
8167  plslabelfunc command. \n\
8168  s: Enables subticks between major ticks, only valid if t is\n\
8169  also specified. \n\
8170  t: Draws major ticks. \n\
8171  u: If this is specified, the text label for the axis is\n\
8172  written under the axis. \n\
8173 \n\
8174 \n\
8175  xlabel (const char *, input) : Pointer to character string\n\
8176  specifying text label for the x axis. It is only drawn if u is in\n\
8177  the xopt string. \n\
8178 \n\
8179  xtick (PLFLT, input) : World coordinate interval between major\n\
8180  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8181  generates a suitable tick interval. \n\
8182 \n\
8183  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8184  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8185  generates a suitable minor tick interval. \n\
8186 \n\
8187  yopt (const char *, input) : Pointer to character string specifying\n\
8188  options for the y axis. The string is interpreted in the same way\n\
8189  as xopt. \n\
8190 \n\
8191  ylabel (const char *, input) : Pointer to character string\n\
8192  specifying text label for the y axis. It is only drawn if u is in\n\
8193  the yopt string. \n\
8194 \n\
8195  ytick (PLFLT, input) : World coordinate interval between major\n\
8196  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8197  generates a suitable tick interval. \n\
8198 \n\
8199  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8200  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8201  generates a suitable minor tick interval. \n\
8202 \n\
8203  zopt (const char *, input) : Pointer to character string specifying\n\
8204  options for the z axis. The string can include any combination of\n\
8205  the following letters (upper or lower case) in any order: b: Draws\n\
8206  z axis to the left of the surface plot. \n\
8207  c: Draws z axis to the right of the surface plot. \n\
8208  d: Draws grid lines parallel to the x-y plane behind the\n\
8209  figure. These lines are not drawn until after plot3d or\n\
8210  plmesh are called because of the need for hidden line removal. \n\
8211  f: Always use fixed point numeric labels. \n\
8212  i: Inverts tick marks, so they are drawn away from the center. \n\
8213  l: Labels axis logarithmically. This only affects the labels,\n\
8214  not the data, and so it is necessary to compute the logarithms\n\
8215  of data points before passing them to any of the drawing\n\
8216  routines. \n\
8217  m: Writes numeric labels at major tick intervals on the\n\
8218  right-hand vertical axis. \n\
8219  n: Writes numeric labels at major tick intervals on the\n\
8220  left-hand vertical axis. \n\
8221  o: Use custom labelling function to generate axis label text. \n\
8222  The custom labelling function can be defined with the\n\
8223  plslabelfunc command. \n\
8224  s: Enables subticks between major ticks, only valid if t is\n\
8225  also specified. \n\
8226  t: Draws major ticks. \n\
8227  u: If this is specified, the text label is written beside the\n\
8228  left-hand axis. \n\
8229  v: If this is specified, the text label is written beside the\n\
8230  right-hand axis. \n\
8231 \n\
8232 \n\
8233  zlabel (const char *, input) : Pointer to character string\n\
8234  specifying text label for the z axis. It is only drawn if u or v\n\
8235  are in the zopt string. \n\
8236 \n\
8237  ztick (PLFLT, input) : World coordinate interval between major\n\
8238  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8239  generates a suitable tick interval. \n\
8240 \n\
8241  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8242  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8243  generates a suitable minor tick interval. \n\
8244 ";
8245 const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8246 Get character default height and current (scaled) height \n\
8247 \n\
8248 DESCRIPTION:\n\
8249 \n\
8250  Get character default height and current (scaled) height. \n\
8251 \n\
8252  Redacted form: plgchr(p_def, p_ht)\n\
8253 \n\
8254  This function is used in example 23. \n\
8255 \n\
8256 \n\
8257 \n\
8258 SYNOPSIS:\n\
8259 \n\
8260 plgchr(p_def, p_ht)\n\
8261 \n\
8262 ARGUMENTS:\n\
8263 \n\
8264  p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
8265 \n\
8266  p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
8267  height (mm). \n\
8268 ";
8269 const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8270 Set the escape character for text strings \n\
8271 \n\
8272 DESCRIPTION:\n\
8273 \n\
8274  Set the escape character for text strings.\tFrom C (in contrast to\n\
8275  Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8276  selected characters are allowed to prevent the user from shooting\n\
8277  himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8278  with C\'s use of backslash as a character escape). Here are the\n\
8279  allowed escape characters and their corresponding decimal ASCII\n\
8280  values: !, ASCII 33 \n\
8281 \t #, ASCII 35 \n\
8282 \t $, ASCII 36 \n\
8283 \t %, ASCII 37 \n\
8284 \t &, ASCII 38 \n\
8285 \t *, ASCII 42 \n\
8286 \t @, ASCII 64 \n\
8287 \t ^, ASCII 94 \n\
8288 \t ~, ASCII 126 \n\
8289 \n\
8290 \n\
8291  Redacted form: General: plsesc(esc)\n\
8292 \t Perl/PDL: Not available? \n\
8293 \n\
8294 \n\
8295  This function is used in example 29. \n\
8296 \n\
8297 \n\
8298 \n\
8299 SYNOPSIS:\n\
8300 \n\
8301 plsesc(esc)\n\
8302 \n\
8303 ARGUMENTS:\n\
8304 \n\
8305  esc (char, input) : Escape character. \n\
8306 ";
8307 const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8308 Draw a line between two points, accounting for coordinate transforms \n\
8309 \n\
8310 DESCRIPTION:\n\
8311 \n\
8312  Joins the point (\n\
8313  x1, \n\
8314  y1) to (\n\
8315  x2, \n\
8316  y2) . If a global coordinate transform is defined then the line is\n\
8317  broken in to n segments to approximate the path. If no transform is\n\
8318  defined then this simply acts like a call to pljoin. \n\
8319 \n\
8320  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8321 \n\
8322  This function is used in example 22. \n\
8323 \n\
8324 \n\
8325 \n\
8326 SYNOPSIS:\n\
8327 \n\
8328 plpath(n, x1, y1, x2, y2)\n\
8329 \n\
8330 ARGUMENTS:\n\
8331 \n\
8332  n (PLINT, input) : number of points to use to approximate the path. \n\
8333 \n\
8334  x1 (PLFLT, input) : x coordinate of first point. \n\
8335 \n\
8336  y1 (PLFLT, input) : y coordinate of first point. \n\
8337 \n\
8338  x2 (PLFLT, input) : x coordinate of second point. \n\
8339 \n\
8340  y2 (PLFLT, input) : y coordinate of second point. \n\
8341 ";
8342 const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8343 Set up standard window and draw box \n\
8344 \n\
8345 DESCRIPTION:\n\
8346 \n\
8347  Sets up plotter environment for simple graphs by calling pladv and\n\
8348  setting up viewport and window to sensible default values.\tplenv\n\
8349  leaves enough room around most graphs for axis labels and a title.\n\
8350  When these defaults are not suitable, use the individual routines\n\
8351  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
8352  defining the window, and plbox for drawing the box. \n\
8353 \n\
8354  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8355 \n\
8356  This function is used in example 1,3,9,13,14,19-22,29. \n\
8357 \n\
8358 \n\
8359 \n\
8360 SYNOPSIS:\n\
8361 \n\
8362 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8363 \n\
8364 ARGUMENTS:\n\
8365 \n\
8366  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8367  world coordinates). \n\
8368 \n\
8369  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8370  world coordinates). \n\
8371 \n\
8372  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8373  coordinates). \n\
8374 \n\
8375  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8376  coordinates). \n\
8377 \n\
8378  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8379  scales will not be set, the user must set up the scale before\n\
8380  calling plenv using plsvpa, plvasp or other. \n\
8381  0: the x and y axes are scaled independently to use as much of\n\
8382  the screen as possible. \n\
8383  1: the scales of the x and y axes are made equal. \n\
8384  2: the axis of the x and y axes are made equal, and the plot\n\
8385  box will be square. \n\
8386 \n\
8387 \n\
8388  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8389  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
8390  -1: draw box only. \n\
8391  0: draw box, ticks, and numeric tick labels. \n\
8392  1: also draw coordinate axes at x=0 and y=0. \n\
8393  2: also draw a grid at major tick positions in both\n\
8394  coordinates. \n\
8395  3: also draw a grid at minor tick positions in both\n\
8396  coordinates. \n\
8397  10: same as 0 except logarithmic x tick marks. (The x data\n\
8398  have to be converted to logarithms separately.) \n\
8399  11: same as 1 except logarithmic x tick marks. (The x data\n\
8400  have to be converted to logarithms separately.) \n\
8401  12: same as 2 except logarithmic x tick marks. (The x data\n\
8402  have to be converted to logarithms separately.) \n\
8403  13: same as 3 except logarithmic x tick marks. (The x data\n\
8404  have to be converted to logarithms separately.) \n\
8405  20: same as 0 except logarithmic y tick marks. (The y data\n\
8406  have to be converted to logarithms separately.) \n\
8407  21: same as 1 except logarithmic y tick marks. (The y data\n\
8408  have to be converted to logarithms separately.) \n\
8409  22: same as 2 except logarithmic y tick marks. (The y data\n\
8410  have to be converted to logarithms separately.) \n\
8411  23: same as 3 except logarithmic y tick marks. (The y data\n\
8412  have to be converted to logarithms separately.) \n\
8413  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8414  and y data have to be converted to logarithms separately.) \n\
8415  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8416  and y data have to be converted to logarithms separately.) \n\
8417  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8418  and y data have to be converted to logarithms separately.) \n\
8419  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8420  and y data have to be converted to logarithms separately.) \n\
8421  40: same as 0 except date / time x labels. \n\
8422  41: same as 1 except date / time x labels. \n\
8423  42: same as 2 except date / time x labels. \n\
8424  43: same as 3 except date / time x labels. \n\
8425  50: same as 0 except date / time y labels. \n\
8426  51: same as 1 except date / time y labels. \n\
8427  52: same as 2 except date / time y labels. \n\
8428  53: same as 3 except date / time y labels. \n\
8429  60: same as 0 except date / time x and y labels. \n\
8430  61: same as 1 except date / time x and y labels. \n\
8431  62: same as 2 except date / time x and y labels. \n\
8432  63: same as 3 except date / time x and y labels. \n\
8433  70: same as 0 except custom x and y labels. \n\
8434  71: same as 1 except custom x and y labels. \n\
8435  72: same as 2 except custom x and y labels. \n\
8436  73: same as 3 except custom x and y labels. \n\
8437 ";
8438 const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8439 Grid data from irregularly sampled data \n\
8440 \n\
8441 DESCRIPTION:\n\
8442 \n\
8443  Real world data is frequently irregularly sampled, but all PLplot 3D\n\
8444  plots require data placed in a uniform grid. This function takes\n\
8445  irregularly sampled data from three input arrays x[npts], y[npts], and\n\
8446  z[npts], reads the desired grid location from input arrays xg[nptsx]\n\
8447  and yg[nptsy], and returns the gridded data into output array\n\
8448  zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n\
8449  with the argument type which can have one parameter specified in\n\
8450  argument data. \n\
8451 \n\
8452  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8453 \t Perl/PDL: Not available? \n\
8454 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8455 \n\
8456 \n\
8457  This function is used in example 21. \n\
8458 \n\
8459 \n\
8460 \n\
8461 SYNOPSIS:\n\
8462 \n\
8463 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8464 \n\
8465 ARGUMENTS:\n\
8466 \n\
8467  x (const PLFLT *, input) : The input x array. \n\
8468 \n\
8469  y (const PLFLT *, input) : The input y array. \n\
8470 \n\
8471  z (const PLFLT *, input) : The input z array. Each triple x[i],\n\
8472  y[i], z[i] represents one data sample coordinate. \n\
8473 \n\
8474  npts (PLINT, input) : The number of data samples in the x, y and z\n\
8475  arrays. \n\
8476 \n\
8477  xg (const PLFLT *, input) : The input array that specifies the grid\n\
8478  spacing in the x direction. Usually xg has nptsx equally spaced\n\
8479  values from the minimum to the maximum values of the x input\n\
8480  array. \n\
8481 \n\
8482  nptsx (PLINT, input) : The number of points in the xg array. \n\
8483 \n\
8484  yg (const PLFLT *, input) : The input array that specifies the grid\n\
8485  spacing in the y direction. Similar to the xg parameter. \n\
8486 \n\
8487  nptsy (PLINT, input) : The number of points in the yg array. \n\
8488 \n\
8489  zg (PLFLT **, output) : The output array, where data lies in the\n\
8490  regular grid specified by xg and yg. the zg array must exist or be\n\
8491  allocated by the user prior to the call, and must have dimension\n\
8492  zg[nptsx][nptsy]. \n\
8493 \n\
8494  type (PLINT, input) : The type of gridding algorithm to use, which\n\
8495  can be: GRID_CSA: Bivariate Cubic Spline approximation \n\
8496  GRID_DTLI: Delaunay Triangulation Linear Interpolation \n\
8497  GRID_NNI: Natural Neighbors Interpolation \n\
8498  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n\
8499  GRID_NNLI: Nearest Neighbors Linear Interpolation \n\
8500  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8501  Weighted \n\
8502  For details of the algorithms read the source file plgridd.c. \n\
8503 \n\
8504  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8505  which can be specified through this argument. Currently, for\n\
8506  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8507  use, the lower the value, the noisier (more local) the\n\
8508  approximation is. \n\
8509  GRID_NNLI, data specifies what a thin triangle is, in the\n\
8510  range [1. .. 2.]. High values enable the usage of very thin\n\
8511  triangles for interpolation, possibly resulting in error in\n\
8512  the approximation. \n\
8513  GRID_NNI, only weights greater than data will be accepted. If\n\
8514  0, all weights will be accepted. \n\
8515 ";
8516 const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8517 Clear current (sub)page \n\
8518 \n\
8519 DESCRIPTION:\n\
8520 \n\
8521  Clears the current page, effectively erasing everything that have been\n\
8522  drawn. This command only works with interactive drivers; if the\n\
8523  driver does not support this, the page is filled with the background\n\
8524  color in use. If the current page is divided into subpages, only the\n\
8525  current subpage is erased.\tThe nth subpage can be selected with\n\
8526  pladv(n). \n\
8527 \n\
8528  Redacted form: General: plclear()\n\
8529 \t Perl/PDL: Not available? \n\
8530 \n\
8531 \n\
8532  This function is not used in any examples. \n\
8533 \n\
8534 \n\
8535 \n\
8536 SYNOPSIS:\n\
8537 \n\
8538 plclear()\n\
8539 ";
8540 const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8541 Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n\
8542 \n\
8543 DESCRIPTION:\n\
8544 \n\
8545  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8546  and floating point alpha transparency value. This sets the entire\n\
8547  color map -- only as many colors as specified will be allocated. \n\
8548 \n\
8549  Redacted form: plscmap0a(r, g, b, alpha)\n\
8550 \n\
8551  This function is used in examples 30. \n\
8552 \n\
8553 \n\
8554 \n\
8555 SYNOPSIS:\n\
8556 \n\
8557 plscmap0a(r, g, b, alpha, ncol0)\n\
8558 \n\
8559 ARGUMENTS:\n\
8560 \n\
8561  r (const PLINT *, input) : Pointer to array with set of unsigned\n\
8562  8-bit integers (0-255) representing the degree of red in the\n\
8563  color. \n\
8564 \n\
8565  g (const PLINT *, input) : Pointer to array with set of unsigned\n\
8566  8-bit integers (0-255) representing the degree of green in the\n\
8567  color. \n\
8568 \n\
8569  b (const PLINT *, input) : Pointer to array with set of unsigned\n\
8570  8-bit integers (0-255) representing the degree of blue in the\n\
8571  color. \n\
8572 \n\
8573  alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n\
8574  values (0.0 - 1.0) representing the alpha transparency of the\n\
8575  color. \n\
8576 \n\
8577  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8578  arrays. \n\
8579 ";
8580 const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
8581 Set 8-bit RGB values for given cmap0 color index \n\
8582 \n\
8583 DESCRIPTION:\n\
8584 \n\
8585  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8586  index. Overwrites the previous color value for the given index and,\n\
8587  thus, does not result in any additional allocation of space for\n\
8588  colors. \n\
8589 \n\
8590  Redacted form: plscol0(icol0, r, g, b)\n\
8591 \n\
8592  This function is used in any example 31. \n\
8593 \n\
8594 \n\
8595 \n\
8596 SYNOPSIS:\n\
8597 \n\
8598 plscol0(icol0, r, g, b)\n\
8599 \n\
8600 ARGUMENTS:\n\
8601 \n\
8602  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8603  number of colors (which is set by default, by plscmap0n, or even\n\
8604  by plscmap0). \n\
8605 \n\
8606  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8607  degree of red in the color. \n\
8608 \n\
8609  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8610  degree of green in the color. \n\
8611 \n\
8612  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8613  degree of blue in the color. \n\
8614 ";
8615 const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
8616 Set up transformation from metafile coordinates \n\
8617 \n\
8618 DESCRIPTION:\n\
8619 \n\
8620  Set up transformation from metafile coordinates. The size of the plot\n\
8621  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8622  general-purpose facility just yet (not sure why the user would need\n\
8623  it, for one). \n\
8624 \n\
8625  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8626  dimypmm)\n\
8627 \n\
8628  This function is not used in any examples. \n\
8629 \n\
8630 \n\
8631 \n\
8632 SYNOPSIS:\n\
8633 \n\
8634 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8635 \n\
8636 ARGUMENTS:\n\
8637 \n\
8638  dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
8639 \n\
8640  dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
8641 \n\
8642  dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
8643 \n\
8644  dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
8645 \n\
8646  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8647 \n\
8648  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8649 ";
8650 const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
8651 Creates a new stream and makes it the default \n\
8652 \n\
8653 DESCRIPTION:\n\
8654 \n\
8655  Creates a new stream and makes it the default. Differs from using\n\
8656  plsstrm, in that a free stream number is found, and returned.\n\
8657  Unfortunately, I have to start at stream 1 and work upward, since\n\
8658  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8659  that no initial, library-opening call is required.\tSo stream 0 must\n\
8660  be preallocated, and there is no simple way of determining whether it\n\
8661  is already in use or not. \n\
8662 \n\
8663  Redacted form: plmkstrm(p_strm)\n\
8664 \n\
8665  This function is used in examples 1,20. \n\
8666 \n\
8667 \n\
8668 \n\
8669 SYNOPSIS:\n\
8670 \n\
8671 plmkstrm(p_strm)\n\
8672 \n\
8673 ARGUMENTS:\n\
8674 \n\
8675  p_strm (PLINT *, output) : Pointer to stream number of the created\n\
8676  stream. \n\
8677 ";
8678 const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
8679 Get page parameters \n\
8680 \n\
8681 DESCRIPTION:\n\
8682 \n\
8683  Gets the current page configuration. The length and offset values are\n\
8684  expressed in units that are specific to the current driver. For\n\
8685  instance: screen drivers will usually interpret them as number of\n\
8686  pixels, whereas printer drivers will usually use mm. \n\
8687 \n\
8688  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8689 \n\
8690  This function is used in examples 14 and 31. \n\
8691 \n\
8692 \n\
8693 \n\
8694 SYNOPSIS:\n\
8695 \n\
8696 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8697 \n\
8698 ARGUMENTS:\n\
8699 \n\
8700  p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
8701 \n\
8702  p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n\
8703  y. \n\
8704 \n\
8705  p_xleng (PLINT *, output) : Pointer to x page length value. \n\
8706 \n\
8707  p_yleng (PLINT *, output) : Pointer to y page length value. \n\
8708 \n\
8709  p_xoff (PLINT *, output) : Pointer to x page offset. \n\
8710 \n\
8711  p_yoff (PLINT *, output) : Pointer to y page offset. \n\
8712 ";
8713 const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
8714 Set format for date / time labels \n\
8715 \n\
8716 DESCRIPTION:\n\
8717 \n\
8718  Sets the format for date / time labels. To enable date / time format\n\
8719  labels see the options to plbox and plenv. \n\
8720 \n\
8721  Redacted form: pltimefmt(fmt)\n\
8722 \n\
8723  This function is used in example 29. \n\
8724 \n\
8725 \n\
8726 \n\
8727 SYNOPSIS:\n\
8728 \n\
8729 pltimefmt(fmt)\n\
8730 \n\
8731 ARGUMENTS:\n\
8732 \n\
8733  fmt (const char *, fmt) : This string is passed directly to the\n\
8734  system strftime. See the system documentation for a full list of\n\
8735  conversion specifications for your system. All conversion\n\
8736  specifications take the form of a \'%\' character followed by\n\
8737  further conversion specification character. All other text is\n\
8738  printed as-is. Common options include: %c: The preferred date and\n\
8739  time representation for the current locale. \n\
8740  %d: The day of the month as a decimal number. \n\
8741  %H: The hour as a decimal number using a 24-hour clock. \n\
8742  %j: The day of the year as a decimal number. \n\
8743  %m: The month as a decimal number. \n\
8744  %M: The minute as a decimal number. \n\
8745  %S: The second as a decimal number. \n\
8746  %y: The year as a decimal number without a century. \n\
8747  %Y: The year as a decimal number including a century. \n\
8748 ";
8749 const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
8750 Specify viewport using aspect ratio only \n\
8751 \n\
8752 DESCRIPTION:\n\
8753 \n\
8754  Sets the viewport so that the ratio of the length of the y axis to\n\
8755  that of the x axis is equal to aspect. \n\
8756 \n\
8757  Redacted form: plvasp(aspect)\n\
8758 \n\
8759  This function is used in example 13. \n\
8760 \n\
8761 \n\
8762 \n\
8763 SYNOPSIS:\n\
8764 \n\
8765 plvasp(aspect)\n\
8766 \n\
8767 ARGUMENTS:\n\
8768 \n\
8769  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8770  axis. \n\
8771 ";
8772 const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
8773 Set output file name \n\
8774 \n\
8775 DESCRIPTION:\n\
8776 \n\
8777  Sets the current output file name, if applicable. If the file name\n\
8778  has not been specified and is required by the driver, the user will be\n\
8779  prompted for it. If using the X-windows output driver, this sets the\n\
8780  display name. This routine, if used, must be called before\n\
8781  initializing PLplot. \n\
8782 \n\
8783  Redacted form: plsfnam(fnam)\n\
8784 \n\
8785  This function is used in examples 1,20. \n\
8786 \n\
8787 \n\
8788 \n\
8789 SYNOPSIS:\n\
8790 \n\
8791 plsfnam(fnam)\n\
8792 \n\
8793 ARGUMENTS:\n\
8794 \n\
8795  fnam (const char *, input) : Pointer to file name string. \n\
8796 ";
8797 const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
8798 Vector plot \n\
8799 \n\
8800 DESCRIPTION:\n\
8801 \n\
8802  Draws a vector plot of the vector (\n\
8803  u[\n\
8804  nx][\n\
8805  ny],\n\
8806  v[\n\
8807  nx][\n\
8808  ny]) . The scaling factor for the vectors is given by scale. A\n\
8809  transformation routine pointed to by pltr with a pointer pltr_data for\n\
8810  additional data required by the transformation routine is used to map\n\
8811  indices within the array to the world coordinates. The style of the\n\
8812  vector arrow may be set using plsvect. \n\
8813 \n\
8814  Redacted form: plvect(u, v, scale, pltr, pltr_data)\n\
8815 \n\
8816  This function is used in example 22. \n\
8817 \n\
8818 \n\
8819 \n\
8820 SYNOPSIS:\n\
8821 \n\
8822 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
8823 \n\
8824 ARGUMENTS:\n\
8825 \n\
8826  u, v (const PLFLT * const *, input) : Pointers to a pair of\n\
8827  vectored two-dimensional arrays containing the x and y components\n\
8828  of the vector data to be plotted. \n\
8829 \n\
8830  nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n\
8831 \n\
8832  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
8833  the vectors for plotting. If scale = 0 then the scaling factor is\n\
8834  automatically calculated for the data. If scale < 0 then the\n\
8835  scaling factor is automatically calculated for the data and then\n\
8836  multiplied by -\n\
8837  scale. If scale > 0 then the scaling factor is set to scale. \n\
8838 \n\
8839  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8840  Pointer to function that defines transformation between indices\n\
8841  in array z and the world coordinates (C only). Transformation\n\
8842  functions are provided in the PLplot library: pltr0 for identity\n\
8843  mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
8844  defined by one- and two-dimensional arrays. In addition,\n\
8845  user-supplied routines for the transformation can be used as well.\n\
8846  Examples of all of these approaches are given in the PLplot\n\
8847  documentation. The transformation function should have the form\n\
8848  given by any of pltr0, pltr1, or pltr2. \n\
8849 \n\
8850  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8851  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8852  externally supplied. \n\
8853 ";
8854 const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
8855 Set parameters that define current plot-space window \n\
8856 \n\
8857 DESCRIPTION:\n\
8858 \n\
8859  Set relative minima and maxima that define the current plot-space\n\
8860  window. If plsdiplt is not called the default values of xmin, ymin,\n\
8861  xmax, and ymax are 0., 0., 1., and 1. \n\
8862 \n\
8863  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
8864 \n\
8865  This function is used in example 31. \n\
8866 \n\
8867 \n\
8868 \n\
8869 SYNOPSIS:\n\
8870 \n\
8871 plsdiplt(xmin, ymin, xmax, ymax)\n\
8872 \n\
8873 ARGUMENTS:\n\
8874 \n\
8875  xmin (PLFLT, input) : Relative minimum in x. \n\
8876 \n\
8877  ymin (PLFLT, input) : Relative minimum in y. \n\
8878 \n\
8879  xmax (PLFLT, input) : Relative maximum in x. \n\
8880 \n\
8881  ymax (PLFLT, input) : Relative maximum in y. \n\
8882 ";
8883 const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
8884 Select line style \n\
8885 \n\
8886 DESCRIPTION:\n\
8887 \n\
8888  This sets the line style according to one of eight predefined patterns\n\
8889  (also see plstyl). \n\
8890 \n\
8891  Redacted form: pllsty(lin)\n\
8892 \n\
8893  This function is used in examples 9,12,22,25. \n\
8894 \n\
8895 \n\
8896 \n\
8897 SYNOPSIS:\n\
8898 \n\
8899 pllsty(lin)\n\
8900 \n\
8901 ARGUMENTS:\n\
8902 \n\
8903  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
8904  a continuous line, line style 2 is a line with short dashes and\n\
8905  gaps, line style 3 is a line with long dashes and gaps, line style\n\
8906  4 has long dashes and short gaps and so on. \n\
8907 ";
8908 const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
8909 Plot a glyph at the specified points \n\
8910 \n\
8911 DESCRIPTION:\n\
8912 \n\
8913  Plot a glyph at the specified points. (This function is largely\n\
8914  superseded by plstring which gives access to many[!] more glyphs.) \n\
8915 \n\
8916  Redacted form: plsym(x, y, code)\n\
8917 \n\
8918  This function is used in example 7. \n\
8919 \n\
8920 \n\
8921 \n\
8922 SYNOPSIS:\n\
8923 \n\
8924 plsym(n, x, y, code)\n\
8925 \n\
8926 ARGUMENTS:\n\
8927 \n\
8928  n (PLINT, input) : Number of points in the x and y arrays. \n\
8929 \n\
8930  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
8931  of points. \n\
8932 \n\
8933  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
8934  of points. \n\
8935 \n\
8936  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
8937  to be plotted at each of the n points. \n\
8938 ";
8939 const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
8940 Set the device (keyword) name \n\
8941 \n\
8942 DESCRIPTION:\n\
8943 \n\
8944  Set the device (keyword) name. \n\
8945 \n\
8946  Redacted form: plsdev(devname)\n\
8947 \n\
8948  This function is used in examples 1,14,20. \n\
8949 \n\
8950 \n\
8951 \n\
8952 SYNOPSIS:\n\
8953 \n\
8954 plsdev(devname)\n\
8955 \n\
8956 ARGUMENTS:\n\
8957 \n\
8958  devname (const char *, input) : Pointer to device (keyword) name\n\
8959  string. \n\
8960 ";
8961 const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
8962 Set the background color by 8-bit RGB value \n\
8963 \n\
8964 DESCRIPTION:\n\
8965 \n\
8966  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
8967  (see the PLplot documentation). \n\
8968 \n\
8969  Redacted form: plscolbg(r, g, b)\n\
8970 \n\
8971  This function is used in examples 15,31. \n\
8972 \n\
8973 \n\
8974 \n\
8975 SYNOPSIS:\n\
8976 \n\
8977 plscolbg(r, g, b)\n\
8978 \n\
8979 ARGUMENTS:\n\
8980 \n\
8981  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8982  degree of red in the color. \n\
8983 \n\
8984  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8985  degree of green in the color. \n\
8986 \n\
8987  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8988  degree of blue in the color. \n\
8989 ";
8990 const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
8991 Set parameters incrementally (zoom mode) that define current plot-space window \n\
8992 \n\
8993 DESCRIPTION:\n\
8994 \n\
8995  Set relative minima and maxima incrementally (zoom mode) that define\n\
8996  the current plot-space window. This function has the same effect as\n\
8997  plsdiplt if that function has not been previously called. Otherwise,\n\
8998  this function implements zoom mode using the transformation min_used =\n\
8999  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9000  each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9001  repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
9002 \n\
9003  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9004 \n\
9005  This function is used in example 31. \n\
9006 \n\
9007 \n\
9008 \n\
9009 SYNOPSIS:\n\
9010 \n\
9011 plsdiplz(xmin, ymin, xmax, ymax)\n\
9012 \n\
9013 ARGUMENTS:\n\
9014 \n\
9015  xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
9016 \n\
9017  ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
9018 \n\
9019  xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
9020 \n\
9021  ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
9022 ";
9023 const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9024 Advance to the next family file on the next new page \n\
9025 \n\
9026 DESCRIPTION:\n\
9027 \n\
9028  Advance to the next family file on the next new page. \n\
9029 \n\
9030  Redacted form: plfamadv()\n\
9031 \n\
9032  This function is not used in any examples. \n\
9033 \n\
9034 \n\
9035 \n\
9036 SYNOPSIS:\n\
9037 \n\
9038 plfamadv()\n\
9039 ";
9040 const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9041 Set number of colors in cmap0 \n\
9042 \n\
9043 DESCRIPTION:\n\
9044 \n\
9045  Set number of colors in color map0 (see the PLplot documentation).\n\
9046  Allocate (or reallocate) color map0, and fill with default values for\n\
9047  those colors not previously allocated. The first 16 default colors are\n\
9048  given in the plcol0 documentation. For larger indices the default\n\
9049  color is red. \n\
9050 \n\
9051  The drivers are not guaranteed to support more than 16 colors. \n\
9052 \n\
9053  Redacted form: plscmap0n(ncol0)\n\
9054 \n\
9055  This function is used in examples 15,16,24. \n\
9056 \n\
9057 \n\
9058 \n\
9059 SYNOPSIS:\n\
9060 \n\
9061 plscmap0n(ncol0)\n\
9062 \n\
9063 ARGUMENTS:\n\
9064 \n\
9065  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9066  the map0 palette. If this number is zero or less, then the value\n\
9067  from the previous call to plscmap0n is used and if there is no\n\
9068  previous call, then a default value is used. \n\
9069 ";
9070 const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9071 Plot latitude and longitude lines \n\
9072 \n\
9073 DESCRIPTION:\n\
9074 \n\
9075  Displays latitude and longitude on the current plot. The lines are\n\
9076  plotted in the current color and line style. \n\
9077 \n\
9078  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9079  minlat, maxlat)\n\
9080 \n\
9081  This function is used in example 19. \n\
9082 \n\
9083 \n\
9084 \n\
9085 SYNOPSIS:\n\
9086 \n\
9087 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9088 \n\
9089 ARGUMENTS:\n\
9090 \n\
9091  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9092  supplied function to transform the coordinate longitudes and\n\
9093  latitudes to a plot coordinate system. By using this transform, we\n\
9094  can change from a longitude, latitude coordinate to a polar\n\
9095  stereographic project, for example. Initially, x[0]..[n-1] are\n\
9096  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9097  After the call to mapform(), x[] and y[] should be replaced by the\n\
9098  corresponding plot coordinates. If no transform is desired,\n\
9099  mapform can be replaced by NULL. \n\
9100 \n\
9101  dlong (PLFLT, input) : The interval in degrees at which the\n\
9102  longitude lines are to be plotted. \n\
9103 \n\
9104  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9105  lines are to be plotted. \n\
9106 \n\
9107  minlong (PLFLT, input) : The value of the longitude on the left\n\
9108  side of the plot. The value of minlong must be less than the value\n\
9109  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9110  equal to 360. \n\
9111 \n\
9112  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9113  side of the plot. \n\
9114 \n\
9115  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9116  background. One can always use -90.0 as the boundary outside the\n\
9117  plot window will be automatically eliminated. However, the\n\
9118  program will be faster if one can reduce the size of the\n\
9119  background plotted. \n\
9120 \n\
9121  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9122  background. One can always use 90.0 as the boundary outside the\n\
9123  plot window will be automatically eliminated. \n\
9124 ";
9125 const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9126 Convert RGB color to HLS \n\
9127 \n\
9128 DESCRIPTION:\n\
9129 \n\
9130  Convert RGB color coordinates to HLS \n\
9131 \n\
9132  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9133 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
9134 \n\
9135 \n\
9136  This function is used in example 2. \n\
9137 \n\
9138 \n\
9139 \n\
9140 SYNOPSIS:\n\
9141 \n\
9142 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9143 \n\
9144 ARGUMENTS:\n\
9145 \n\
9146  r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
9147 \n\
9148  g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
9149 \n\
9150  b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
9151 \n\
9152  p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
9153  cone (0.0-360.0) \n\
9154 \n\
9155  p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
9156  fraction of the axis of the colour cone (0.0-1.0) \n\
9157 \n\
9158  p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
9159  fraction of the radius of the colour cone (0.0-1.0) \n\
9160 ";
9161 const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9162 Plot a glyph at the specified 3D points \n\
9163 \n\
9164 DESCRIPTION:\n\
9165 \n\
9166  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9167  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9168  this function similar to what is done for plline3. The glyph is\n\
9169  specified with a PLplot user string. Note that the user string is not\n\
9170  actually limited to one glyph so it is possible (but not normally\n\
9171  useful) to plot more than one glyph at the specified points with this\n\
9172  function. As with plmtex and plptex, the user string can contain FCI\n\
9173  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9174  else PLplot escapes for Hershey or unicode text to determine the\n\
9175  glyph. \n\
9176 \n\
9177  Redacted form: plstring3(x, y, z, string)\n\
9178 \n\
9179  This function is used in example 18. \n\
9180 \n\
9181 \n\
9182 \n\
9183 SYNOPSIS:\n\
9184 \n\
9185 plstring3(n, x, y, z, string)\n\
9186 \n\
9187 ARGUMENTS:\n\
9188 \n\
9189  n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
9190 \n\
9191  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9192  of points. \n\
9193 \n\
9194  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9195  of points. \n\
9196 \n\
9197  z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9198  of points. \n\
9199 \n\
9200  string (const char *, input) : PLplot user string corresponding to\n\
9201  the glyph to be plotted at each of the n points. \n\
9202 ";
9203 const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9204 Switch to text screen \n\
9205 \n\
9206 DESCRIPTION:\n\
9207 \n\
9208  Sets an interactive device to text mode, used in conjunction with\n\
9209  plgra to allow graphics and text to be interspersed. On a device\n\
9210  which supports separate text and graphics windows, this command causes\n\
9211  control to be switched to the text window.\tThis can be useful for\n\
9212  printing diagnostic messages or getting user input, which would\n\
9213  otherwise interfere with the plots. The program must switch back to\n\
9214  the graphics window before issuing plot commands, as the text (or\n\
9215  console) device will probably become quite confused otherwise. If\n\
9216  already in text mode, this command is ignored. It is also ignored on\n\
9217  devices which only support a single window or use a different method\n\
9218  for shifting focus (see also plgra). \n\
9219 \n\
9220  Redacted form: pltext()\n\
9221 \n\
9222  This function is used in example 1. \n\
9223 \n\
9224 \n\
9225 \n\
9226 SYNOPSIS:\n\
9227 \n\
9228 pltext()\n\
9229 ";
9230 const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9231 Get parameters that define current plot-space window \n\
9232 \n\
9233 DESCRIPTION:\n\
9234 \n\
9235  Get relative minima and maxima that define current plot-space window.\n\
9236  If plsdiplt has not been called the default values pointed to by\n\
9237  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
9238 \n\
9239  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9240 \n\
9241  This function is used in example 31. \n\
9242 \n\
9243 \n\
9244 \n\
9245 SYNOPSIS:\n\
9246 \n\
9247 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9248 \n\
9249 ARGUMENTS:\n\
9250 \n\
9251  p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
9252 \n\
9253  p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
9254 \n\
9255  p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
9256 \n\
9257  p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
9258 ";
9259 const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9260 Get the (current) run level \n\
9261 \n\
9262 DESCRIPTION:\n\
9263 \n\
9264  Get the (current) run level. Valid settings are: 0, uninitialized \n\
9265 \t 1,\tinitialized \n\
9266 \t 2,\tviewport defined \n\
9267 \t 3,\tworld coordinates defined \n\
9268 \n\
9269 \n\
9270  Redacted form: plglevel(p_level)\n\
9271 \n\
9272  This function is used in example 31. \n\
9273 \n\
9274 \n\
9275 \n\
9276 SYNOPSIS:\n\
9277 \n\
9278 plglevel(p_level)\n\
9279 \n\
9280 ARGUMENTS:\n\
9281 \n\
9282  p_level (PLINT *, output) : Pointer to the run level. \n\
9283 ";
9284 const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9285 Plot a histogram from binned data \n\
9286 \n\
9287 DESCRIPTION:\n\
9288 \n\
9289  Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9290  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9291  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9292  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9293  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9294  placed midway between the values in the x array. Also see plhist for\n\
9295  drawing histograms from unbinned data. \n\
9296 \n\
9297  Redacted form: General: plbin(x, y, opt)\n\
9298 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9299 \t Python: plbin(nbin, x, y, opt)\n\
9300 \n\
9301 \n\
9302  This function is not used in any examples. \n\
9303 \n\
9304 \n\
9305 \n\
9306 SYNOPSIS:\n\
9307 \n\
9308 plbin(nbin, x, y, opt)\n\
9309 \n\
9310 ARGUMENTS:\n\
9311 \n\
9312  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9313  and y arrays.) \n\
9314 \n\
9315  x (const PLFLT *, input) : Pointer to array containing values\n\
9316  associated with bins. These must form a strictly increasing\n\
9317  sequence. \n\
9318 \n\
9319  y (const PLFLT *, input) : Pointer to array containing number of\n\
9320  points in bin. This is a PLFLT (instead of PLINT) array so as to\n\
9321  allow histograms of probabilities, etc. \n\
9322 \n\
9323  opt (PLINT, input) : Is a combination of several flags:\n\
9324  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9325  outer bins are expanded to fill up the entire x-axis and bins of\n\
9326  zero height are simply drawn. \n\
9327  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9328  between the x values. If the values in x are equally spaced,\n\
9329  the values are the center values of the bins. \n\
9330  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9331  size as the ones inside. \n\
9332  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9333  (there is a gap for such bins). \n\
9334 ";
9335 const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9336 Plot a 2D matrix using cmap1 \n\
9337 \n\
9338 DESCRIPTION:\n\
9339 \n\
9340  Plot a 2D matrix using cmap1. \n\
9341 \n\
9342  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n\
9343  zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n\
9344 \n\
9345 \n\
9346  This function is used in example 20. \n\
9347 \n\
9348 \n\
9349 \n\
9350 SYNOPSIS:\n\
9351 \n\
9352 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9353 \n\
9354 ARGUMENTS:\n\
9355 \n\
9356  idata (const PLFLT * const *, input) : A 2D array of values\n\
9357  (intensities) to plot. Should have dimensions idata[nx][ny]. \n\
9358 \n\
9359  nx, ny (PLINT, input) : Dimensions of idata \n\
9360 \n\
9361  xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n\
9362  Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n\
9363  idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n\
9364 \n\
9365  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9366  (inclusive) will be plotted. \n\
9367 \n\
9368  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9369  values to use for value to color mappings. A datum equal to or\n\
9370  less than valuemin will be plotted with color 0.0, while a datum\n\
9371  equal to or greater than valuemax will be plotted with color 1.0. \n\
9372  Data between valuemin and valuemax map linearly to colors between\n\
9373  0.0 and 1.0. \n\
9374 \n\
9375  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
9376  Pointer to function that defines a transformation between the\n\
9377  data in the array idata and world coordinates. An input\n\
9378  coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n\
9379  while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n\
9380  Some transformation functions are provided in the PLplot library:\n\
9381  pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n\
9382  mappings respectively defined by one- and two-dimensional arrays. \n\
9383  In addition, user-supplied routines for the transformation can be\n\
9384  used as well. Examples of all of these approaches are given in\n\
9385  the PLplot documentation. The transformation function should have\n\
9386  the form given by any of pltr0, pltr1, or pltr2. \n\
9387 \n\
9388  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9389  information to pltr0, pltr1, pltr2, or whatever routine is\n\
9390  externally supplied. \n\
9391 ";
9392 const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
9393 Get family, style and weight of the current font \n\
9394 \n\
9395 DESCRIPTION:\n\
9396 \n\
9397  Gets information about current font. See the PLplot documentation for\n\
9398  more information on font selection. \n\
9399 \n\
9400  Redacted form: plgfont(p_family, p_style, p_weight)\n\
9401 \n\
9402  This function is used in example 23. \n\
9403 \n\
9404 \n\
9405 \n\
9406 SYNOPSIS:\n\
9407 \n\
9408 plgfont(p_family, p_style, p_weight)\n\
9409 \n\
9410 ARGUMENTS:\n\
9411 \n\
9412  p_family (PLINT *, output) : Pointer to variable with the current\n\
9413  font family. The available values are given by the PL_FCI_*\n\
9414  constants in plplot.h. Current options are PL_FCI_SANS,\n\
9415  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9416  p_family is NULL then the font family is not returned. \n\
9417 \n\
9418  p_style (PLINT *, output) : Pointer to variable with the current\n\
9419  font style. The available values are given by the PL_FCI_*\n\
9420  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9421  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
9422  font style is not returned. \n\
9423 \n\
9424  p_weight (PLINT *, output) : Pointer to variable with the current\n\
9425  font weight. The available values are given by the PL_FCI_*\n\
9426  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9427  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9428  returned. \n\
9429 ";
9430 const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
9431 Get z axis parameters \n\
9432 \n\
9433 DESCRIPTION:\n\
9434 \n\
9435  Identical to plgxax, except that arguments are flags for z axis. See\n\
9436  the description of plgxax for more detail. \n\
9437 \n\
9438  Redacted form: plgzax(p_digmax, p_digits)\n\
9439 \n\
9440  This function is used in example 31. \n\
9441 \n\
9442 \n\
9443 \n\
9444 SYNOPSIS:\n\
9445 \n\
9446 plgzax(p_digmax, p_digits)\n\
9447 \n\
9448 ARGUMENTS:\n\
9449 \n\
9450  p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
9451  number of digits for the z axis. If nonzero, the printed label\n\
9452  has been switched to a floating point representation when the\n\
9453  number of digits exceeds p_digmax. \n\
9454 \n\
9455  p_digits (PLINT *, output) : Pointer to variable with the actual\n\
9456  number of digits for the numeric labels (z axis) from the last\n\
9457  plot. \n\
9458 ";
9459 const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
9460 Write text inside the viewport of a 3D plot \n\
9461 \n\
9462 DESCRIPTION:\n\
9463 \n\
9464  Writes text at a specified position and inclination and with a\n\
9465  specified shear within the viewport. Text is clipped at the viewport\n\
9466  boundaries. The reference point of a string lies along a line passing\n\
9467  through the string at half the height of a capital letter.\tThe\n\
9468  position of the reference point along this line is determined by just,\n\
9469  and the reference point is placed at world coordinates (\n\
9470  wx, \n\
9471  wy, \n\
9472  wz) within the viewport. The inclination and shear of the string is\n\
9473  specified in terms of differences of world coordinates making it easy\n\
9474  to write text parallel to a line in a graph. \n\
9475 \n\
9476  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n\
9477 \n\
9478  This function is used in example 28. \n\
9479 \n\
9480 \n\
9481 \n\
9482 SYNOPSIS:\n\
9483 \n\
9484 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9485 \n\
9486 ARGUMENTS:\n\
9487 \n\
9488  wx (PLFLT, input) : x world coordinate of reference point of\n\
9489  string. \n\
9490 \n\
9491  wy (PLFLT, input) : y world coordinate of reference point of\n\
9492  string. \n\
9493 \n\
9494  wz (PLFLT, input) : z world coordinate of reference point of\n\
9495  string. \n\
9496 \n\
9497  dx (PLFLT, input) : Together with dy and \n\
9498  dz , this specifies the inclination of the string. The baseline of\n\
9499  the string is parallel to a line joining (\n\
9500  x, \n\
9501  y, \n\
9502  z) to (\n\
9503  x+\n\
9504  dx, \n\
9505  y+\n\
9506  dy, \n\
9507  z+\n\
9508  dz) . \n\
9509 \n\
9510  dy (PLFLT, input) : Together with dx and \n\
9511  dz, this specifies the inclination of the string. \n\
9512 \n\
9513  dz (PLFLT, input) : Together with dx and \n\
9514  dy, this specifies the inclination of the string. \n\
9515 \n\
9516  sx (PLFLT, input) : Together with sy and \n\
9517  sz , this specifies the shear of the string. The string is sheared so\n\
9518  that the characters are vertically parallel to a line joining (\n\
9519  x, \n\
9520  y, \n\
9521  z) to (\n\
9522  x+\n\
9523  sx, \n\
9524  y+\n\
9525  sy, \n\
9526  z+\n\
9527  sz) . If sx = \n\
9528  sy = \n\
9529  sz = 0.) then the text is not sheared. \n\
9530 \n\
9531  sy (PLFLT, input) : Together with sx and \n\
9532  sz, this specifies shear of the string. \n\
9533 \n\
9534  sz (PLFLT, input) : Together with sx and \n\
9535  sy, this specifies shear of the string. \n\
9536 \n\
9537  just (PLFLT, input) : Specifies the position of the string relative\n\
9538  to its reference point. If just=0. , the reference point is at\n\
9539  the left and if just=1. , it is at the right of the string. Other\n\
9540  values of just give intermediate justifications. \n\
9541 \n\
9542  text (const char *, input) : The string to be written out. \n\
9543 ";
9544 const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
9545 Draw a box with axes, etc. with arbitrary origin \n\
9546 \n\
9547 DESCRIPTION:\n\
9548 \n\
9549  Draws a box around the currently defined viewport with arbitrary\n\
9550  world-coordinate origin specified by x0 and y0 and labels it with\n\
9551  world coordinate values appropriate to the window.\tThus plaxes should\n\
9552  only be called after defining both viewport and window. The character\n\
9553  strings xopt and yopt specify how the box should be drawn as described\n\
9554  below. If ticks and/or subticks are to be drawn for a particular\n\
9555  axis, the tick intervals and number of subintervals may be specified\n\
9556  explicitly, or they may be defaulted by setting the appropriate\n\
9557  arguments to zero. \n\
9558 \n\
9559  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9560  ytick, nysub)\n\
9561 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9562  yopt)\n\
9563 \n\
9564 \n\
9565  This function is not used in any examples. \n\
9566 \n\
9567 \n\
9568 \n\
9569 SYNOPSIS:\n\
9570 \n\
9571 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9572 \n\
9573 ARGUMENTS:\n\
9574 \n\
9575  x0 (PLFLT, input) : World X coordinate of origin. \n\
9576 \n\
9577  y0 (PLFLT, input) : World Y coordinate of origin. \n\
9578 \n\
9579  xopt (const char *, input) : Pointer to character string specifying\n\
9580  options for horizontal axis. The string can include any\n\
9581  combination of the following letters (upper or lower case) in any\n\
9582  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
9583  is vertical line (x=0). \n\
9584  b: Draws bottom (X) or left (Y) edge of frame. \n\
9585  c: Draws top (X) or right (Y) edge of frame. \n\
9586  d: Plot labels as date / time. Values are assumed to be\n\
9587  seconds since the epoch (as used by gmtime). \n\
9588  f: Always use fixed point numeric labels. \n\
9589  g: Draws a grid at the major tick interval. \n\
9590  h: Draws a grid at the minor tick interval. \n\
9591  i: Inverts tick marks, so they are drawn outwards, rather than\n\
9592  inwards. \n\
9593  l: Labels axis logarithmically. This only affects the labels,\n\
9594  not the data, and so it is necessary to compute the logarithms\n\
9595  of data points before passing them to any of the drawing\n\
9596  routines. \n\
9597  m: Writes numeric labels at major tick intervals in the\n\
9598  unconventional location (above box for X, right of box for Y). \n\
9599  n: Writes numeric labels at major tick intervals in the\n\
9600  conventional location (below box for X, left of box for Y). \n\
9601  o: Use custom labelling function to generate axis label text. \n\
9602  The custom labelling function can be defined with the\n\
9603  plslabelfunc command. \n\
9604  s: Enables subticks between major ticks, only valid if t is\n\
9605  also specified. \n\
9606  t: Draws major ticks. \n\
9607  u: Exactly like \"b\" except don\'t draw edge line. \n\
9608  w: Exactly like \"c\" except don\'t draw edge line. \n\
9609  x: Exactly like \"t\" (including the side effect of the\n\
9610  numerical labels for the major ticks) except exclude drawing\n\
9611  the major and minor tick marks. \n\
9612 \n\
9613 \n\
9614  xtick (PLFLT, input) : World coordinate interval between major\n\
9615  ticks on the x axis. If it is set to zero, PLplot automatically\n\
9616  generates a suitable tick interval. \n\
9617 \n\
9618  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9619  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9620  generates a suitable minor tick interval. \n\
9621 \n\
9622  yopt (const char *, input) : Pointer to character string specifying\n\
9623  options for vertical axis. The string can include any combination\n\
9624  of the letters defined above for xopt, and in addition may\n\
9625  contain: v: Write numeric labels for vertical axis parallel to the\n\
9626  base of the graph, rather than parallel to the axis. \n\
9627 \n\
9628 \n\
9629  ytick (PLFLT, input) : World coordinate interval between major\n\
9630  ticks on the y axis. If it is set to zero, PLplot automatically\n\
9631  generates a suitable tick interval. \n\
9632 \n\
9633  nysub (PLINT, input) : Number of subintervals between major y axis\n\
9634  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9635  generates a suitable minor tick interval. \n\
9636 ";
9637 const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
9638 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
9639 \n\
9640 DESCRIPTION:\n\
9641 \n\
9642  Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
9643 \n\
9644  Redacted form: plgcolbg(r, g, b)\n\
9645 \n\
9646  This function is used in example 31. \n\
9647 \n\
9648 \n\
9649 \n\
9650 SYNOPSIS:\n\
9651 \n\
9652 plgcolbg(r, g, b)\n\
9653 \n\
9654 ARGUMENTS:\n\
9655 \n\
9656  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9657  representing the degree of red in the color. \n\
9658 \n\
9659  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9660  representing the degree of green in the color. \n\
9661 \n\
9662  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9663  representing the degree of blue in the color. \n\
9664 ";
9665 const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
9666 Plot a glyph at the specified 3D points \n\
9667 \n\
9668 DESCRIPTION:\n\
9669 \n\
9670  Plot a glyph at the specified 3D points. (This function is largely\n\
9671  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9672  Set up the call to this function similar to what is done for plline3.\n\
9673  code=-1 means try to just draw a point. Right now it\'s just a move\n\
9674  and a draw at the same place. Not ideal, since a sufficiently\n\
9675  intelligent output device may optimize it away, or there may be faster\n\
9676  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9677  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9678  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9679  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9680  code <= 127 the corresponding printable ASCII character is plotted. \n\
9681 \n\
9682  Redacted form: plpoin3(x, y, z, code)\n\
9683 \n\
9684  This function is not used in any example. \n\
9685 \n\
9686 \n\
9687 \n\
9688 SYNOPSIS:\n\
9689 \n\
9690 plpoin3(n, x, y, z, code)\n\
9691 \n\
9692 ARGUMENTS:\n\
9693 \n\
9694  n (PLINT, input) : Number of points in the x and y arrays. \n\
9695 \n\
9696  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9697  of points. \n\
9698 \n\
9699  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9700  of points. \n\
9701 \n\
9702  z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9703  of points. \n\
9704 \n\
9705  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
9706  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
9707  each of the n points. \n\
9708 ";
9709 const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
9710 Draw a polygon in 3 space \n\
9711 \n\
9712 DESCRIPTION:\n\
9713 \n\
9714  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
9715  like plline3, but differs from that function in that plpoly3 attempts\n\
9716  to determine if the polygon is viewable depending on the order of the\n\
9717  points within the arrays and the value of ifcc. If the back of\n\
9718  polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
9719  you want, then use plline3 instead. \n\
9720 \n\
9721  The points are assumed to be in a plane, and the directionality of the\n\
9722  plane is determined from the first three points. Additional points do\n\
9723  not have to lie on the plane defined by the first three, but if they\n\
9724  do not, then the determination of visibility obviously can\'t be 100%\n\
9725  accurate... So if you\'re 3 space polygons are too far from planar,\n\
9726  consider breaking them into smaller polygons. 3 points define a plane\n\
9727  :-). \n\
9728 \n\
9729  Bugs: If one of the first two segments is of zero length, or if they\n\
9730  are co-linear, the calculation of visibility has a 50/50 chance of\n\
9731  being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
9732  of this problem. (Search for 20.1). \n\
9733 \n\
9734  Redacted form: plpoly3(x, y, z, code)\n\
9735 \n\
9736  This function is used in example 18. \n\
9737 \n\
9738 \n\
9739 \n\
9740 SYNOPSIS:\n\
9741 \n\
9742 plpoly3(n, x, y, z, draw, ifcc)\n\
9743 \n\
9744 ARGUMENTS:\n\
9745 \n\
9746  n (PLINT, input) : Number of points defining line. \n\
9747 \n\
9748  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
9749  points. \n\
9750 \n\
9751  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9752  points. \n\
9753 \n\
9754  z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
9755  points. \n\
9756 \n\
9757  draw (const PLBOOL *, input) : Pointer to array which controls\n\
9758  drawing the segments of the polygon. If draw[i] is true, then the\n\
9759  polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n\
9760 \n\
9761  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
9762  polygon is determined by assuming the points are laid out in a\n\
9763  counter-clockwise order. Otherwise, the directionality of the\n\
9764  polygon is determined by assuming the points are laid out in a\n\
9765  clockwise order. \n\
9766 ";
9767 const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
9768 Set the background color by 8-bit RGB value and double alpha transparency value. \n\
9769 \n\
9770 DESCRIPTION:\n\
9771 \n\
9772  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9773  (see the PLplot documentation) and double alpha transparency value. \n\
9774 \n\
9775  This function is used in example 31. \n\
9776 \n\
9777 \n\
9778 \n\
9779 SYNOPSIS:\n\
9780 \n\
9781 plscolbga(r, g, b, alpha)\n\
9782 \n\
9783 ARGUMENTS:\n\
9784 \n\
9785  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9786  degree of red in the color. \n\
9787 \n\
9788  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9789  degree of green in the color. \n\
9790 \n\
9791  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9792  degree of blue in the color. \n\
9793 \n\
9794  alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
9795  alpha transparency value of the color. \n\
9796 ";
9797 const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
9798 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n\
9799 \n\
9800 DESCRIPTION:\n\
9801 \n\
9802  Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
9803  alpha transparency value. \n\
9804 \n\
9805  This function is used in example 31. \n\
9806 \n\
9807 \n\
9808 \n\
9809 SYNOPSIS:\n\
9810 \n\
9811 plgcolbga(r, g, b, alpha)\n\
9812 \n\
9813 ARGUMENTS:\n\
9814 \n\
9815  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9816  representing the degree of red in the color. \n\
9817 \n\
9818  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9819  representing the degree of green in the color. \n\
9820 \n\
9821  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9822  representing the degree of blue in the color. \n\
9823 \n\
9824  alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
9825  value. \n\
9826 ";
9827 const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
9828 Draw x error bar \n\
9829 \n\
9830 DESCRIPTION:\n\
9831 \n\
9832  Draws a set of n horizontal error bars, the i\'th error bar extending\n\
9833  from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
9834  error bar are of length equal to the minor tick length (settable using\n\
9835  plsmin). \n\
9836 \n\
9837  Redacted form: General: plerrx(xmin, ymax, y)\n\
9838 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
9839 \n\
9840 \n\
9841  This function is used in example 29. \n\
9842 \n\
9843 \n\
9844 \n\
9845 SYNOPSIS:\n\
9846 \n\
9847 plerrx(n, xmin, xmax, y)\n\
9848 \n\
9849 ARGUMENTS:\n\
9850 \n\
9851  n (PLINT, input) : Number of error bars to draw. \n\
9852 \n\
9853  xmin (const PLFLT *, input) : Pointer to array with x coordinates\n\
9854  of left-hand endpoint of error bars. \n\
9855 \n\
9856  xmax (const PLFLT *, input) : Pointer to array with x coordinates\n\
9857  of right-hand endpoint of error bars. \n\
9858 \n\
9859  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9860  error bar. \n\
9861 ";
9862 const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
9863 Eject current page \n\
9864 \n\
9865 DESCRIPTION:\n\
9866 \n\
9867  Clears the graphics screen of an interactive device, or ejects a page\n\
9868  on a plotter. See plbop for more information. \n\
9869 \n\
9870  Redacted form: pleop()\n\
9871 \n\
9872  This function is used in example 2,14. \n\
9873 \n\
9874 \n\
9875 \n\
9876 SYNOPSIS:\n\
9877 \n\
9878 pleop()\n\
9879 ";
9880 const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
9881 Convert HLS color to RGB \n\
9882 \n\
9883 DESCRIPTION:\n\
9884 \n\
9885  Convert HLS color coordinates to RGB. \n\
9886 \n\
9887  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9888 \t Perl/PDL: Not available? Implemented as plhls? \n\
9889 \n\
9890 \n\
9891  This function is used in example 2. \n\
9892 \n\
9893 \n\
9894 \n\
9895 SYNOPSIS:\n\
9896 \n\
9897 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9898 \n\
9899 ARGUMENTS:\n\
9900 \n\
9901  h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
9902 \n\
9903  l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
9904  of the colour cone (0.0-1.0) \n\
9905 \n\
9906  s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
9907  radius of the colour cone (0.0-1.0) \n\
9908 \n\
9909  p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
9910  colour \n\
9911 \n\
9912  p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
9913  colour \n\
9914 \n\
9915  p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
9916  colour \n\
9917 ";
9918 const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
9919 Plot all or a subset of Shapefile data, filling the polygons \n\
9920 \n\
9921 DESCRIPTION:\n\
9922 \n\
9923  As per plmapline, however the items are filled in the same way as\n\
9924  plfill. \n\
9925 \n\
9926  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
9927  plotentries)\n\
9928 \n\
9929  This function is used in example 19. \n\
9930 \n\
9931 \n\
9932 \n\
9933 SYNOPSIS:\n\
9934 \n\
9935 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
9936 \n\
9937 ARGUMENTS:\n\
9938 \n\
9939  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9940  supplied function to transform the coordinates given in the\n\
9941  shapefile into a plot coordinate system. By using this transform,\n\
9942  we can change from a longitude, latitude coordinate to a polar\n\
9943  stereographic project, for example. Initially, x[0]..[n-1] are\n\
9944  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9945  After the call to mapform(), x[] and y[] should be replaced by the\n\
9946  corresponding plot coordinates. If no transform is desired,\n\
9947  mapform can be replaced by NULL. \n\
9948 \n\
9949  name (const char *, input) : The file name of a set of Shapefile\n\
9950  files without the file extension. \n\
9951 \n\
9952  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
9953  be in the same units as used by the Shapefile. You could use a\n\
9954  very large negative number to plot everything, but you can improve\n\
9955  performance by limiting the area drawn. The units must match those\n\
9956  of the Shapefile projection, which may be for example longitude or\n\
9957  distance. The value of minx must be less than the value of maxx. \n\
9958 \n\
9959  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
9960  use a very large number to plot everything, but you can improve\n\
9961  performance by limiting the area drawn. \n\
9962 \n\
9963  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
9964  be in the same units as used by the Shapefile. You could use a\n\
9965  very large negative number to plot everything, but you can improve\n\
9966  performance by limiting the area drawn. The units must match those\n\
9967  of the Shapefile projection, which may be for example latitude or\n\
9968  distance. The value of miny must be less than the value of maxy. \n\
9969 \n\
9970  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
9971  use a very large number to plot everything, but you can improve\n\
9972  performance by limiting the area drawn. \n\
9973 \n\
9974  plotentries (const PLINT *, input) : An array of integers\n\
9975  indicating the elements of the Shapefile (zero indexed) which will\n\
9976  be drawn. Setting plotentries to NULL will plot all elements of\n\
9977  the Shapefile. \n\
9978 \n\
9979  nplotentries (PLINT, input) : The number of items in plotentries.\n\
9980  Ignored if plotentries is NULL. \n\
9981 ";
9982 const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
9983 Draw y error bar \n\
9984 \n\
9985 DESCRIPTION:\n\
9986 \n\
9987  Draws a set of n vertical error bars, the i\'th error bar extending\n\
9988  from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
9989  error bar are of length equal to the minor tick length (settable using\n\
9990  plsmin). \n\
9991 \n\
9992  Redacted form: General: plerry(x, ymin, ymax)\n\
9993 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
9994 \n\
9995 \n\
9996  This function is used in example 29. \n\
9997 \n\
9998 \n\
9999 \n\
10000 SYNOPSIS:\n\
10001 \n\
10002 plerry(n, x, ymin, ymax)\n\
10003 \n\
10004 ARGUMENTS:\n\
10005 \n\
10006  n (PLINT, input) : Number of error bars to draw. \n\
10007 \n\
10008  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
10009  error bars. \n\
10010 \n\
10011  ymin (const PLFLT *, input) : Pointer to array with y coordinates\n\
10012  of lower endpoint of error bars. \n\
10013 \n\
10014  ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n\
10015  upper endpoint of error bar. \n\
10016 ";
10017 const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10018 Set FCI (font characterization integer) \n\
10019 \n\
10020 DESCRIPTION:\n\
10021 \n\
10022  Sets font characteristics to be used at the start of the next string\n\
10023  using the FCI approach. See the PLplot documentation for more\n\
10024  information. \n\
10025 \n\
10026  Redacted form: General: plsfci(fci)\n\
10027 \t Perl/PDL: Not available? \n\
10028 \n\
10029 \n\
10030  This function is used in example 23. \n\
10031 \n\
10032 \n\
10033 \n\
10034 SYNOPSIS:\n\
10035 \n\
10036 plsfci(fci)\n\
10037 \n\
10038 ARGUMENTS:\n\
10039 \n\
10040  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10041  of FCI. \n\
10042 ";
10043 const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10044 Select area fill pattern \n\
10045 \n\
10046 DESCRIPTION:\n\
10047 \n\
10048  Select one of eight predefined area fill patterns to use (also see\n\
10049  plpat). Setting the fill style to 0 gives a solid fill. \n\
10050 \n\
10051  Redacted form: plpsty(patt)\n\
10052 \n\
10053  This function is used in examples 12,13,15,16,25. \n\
10054 \n\
10055 \n\
10056 \n\
10057 SYNOPSIS:\n\
10058 \n\
10059 plpsty(patt)\n\
10060 \n\
10061 ARGUMENTS:\n\
10062 \n\
10063  patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
10064  horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
10065  consists of lines at 45 degrees angle (upward), and so on. \n\
10066 ";
10067 const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10068 Set symbol size \n\
10069 \n\
10070 DESCRIPTION:\n\
10071 \n\
10072  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10073  plsym. The actual height of a symbol is the product of the default\n\
10074  symbol size and a scaling factor as for the character height. \n\
10075 \n\
10076  Redacted form: plssym(def, scale)\n\
10077 \n\
10078  This function is used in example 29. \n\
10079 \n\
10080 \n\
10081 \n\
10082 SYNOPSIS:\n\
10083 \n\
10084 plssym(def, scale)\n\
10085 \n\
10086 ARGUMENTS:\n\
10087 \n\
10088  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10089  should be set to zero if the default height is to remain\n\
10090  unchanged. \n\
10091 \n\
10092  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10093  actual symbol height. \n\
10094 ";
10095 const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10096 Initialization \n\
10097 \n\
10098 DESCRIPTION:\n\
10099 \n\
10100  Alternative to plstar for initializing the plotting package. The\n\
10101  device name keyword for the desired output device must be supplied as\n\
10102  an argument. These keywords are the same as those printed out by\n\
10103  plstar. If the requested device is not available, or if the input\n\
10104  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10105  is used. This routine also divides the output device page into nx by\n\
10106  ny subpages, each of which may be used independently. The subroutine\n\
10107  pladv is used to advance from one subpage to the next. \n\
10108 \n\
10109  Redacted form: General: plstart(devname, nx, ny)\n\
10110 \t Perl/PDL: plstart(nx, ny, devname)\n\
10111 \n\
10112 \n\
10113  This function is not used in any examples. \n\
10114 \n\
10115 \n\
10116 \n\
10117 SYNOPSIS:\n\
10118 \n\
10119 plstart(devname, nx, ny)\n\
10120 \n\
10121 ARGUMENTS:\n\
10122 \n\
10123  devname (const char *, input) : Device name keyword of the required\n\
10124  output device. If NULL or if the first character is a ``?\'\', the\n\
10125  normal (prompted) start up is used. \n\
10126 \n\
10127  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10128  horizontal direction. \n\
10129 \n\
10130  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10131  vertical direction. \n\
10132 ";
10133 
10134 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10135  PLINT arg1 ;
10136  PLINT *arg2 = (PLINT *) 0 ;
10137  char **arg3 = (char **) 0 ;
10138  Matrix temp1 ;
10139  octave_value_list _out;
10140  octave_value_list *_outp=&_out;
10141  octave_value _outv;
10142 
10143  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10144  SWIG_fail;
10145  }
10146  {
10147  if ( _n_dims( args(0) ) > 1 )
10148  {
10149  error( "argument must be a scalar or vector" ); SWIG_fail;
10150  }
10151  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10152  arg2 = new PLINT[Alen];
10153  temp1 = args(0).matrix_value();
10154  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10155  }
10156  {
10157  charMatrix temp_matrix;
10158  Cell temp_cell;
10159  char *tmp_cstring;
10160  std::string str;
10161  size_t max_length = 0, non_blank_length;
10162  int i, ifcell;
10163  if ( _n_dims( args(1) ) > 2 )
10164  {
10165  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10166  }
10167  if ( !args(1).is_empty() )
10168  {
10169  if ( _dim( args(1), 0 ) != Alen )
10170  {
10171  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10172  }
10173  arg3 = new char*[Alen];
10174  ifcell = args(1).is_cell();
10175  if ( ifcell )
10176  {
10177  temp_cell = args(1).cell_value();
10178  }
10179  else
10180  {
10181  temp_matrix = args(1).char_matrix_value();
10182  // Allow one extra space for null termination.
10183  max_length = _dim( args(1), 1 ) + 1;
10184  }
10185 
10186  for ( i = 0; i < Alen; i++ )
10187  {
10188  // Must copy string to "permanent" location because the string
10189  // location corresponding to tmp_cstring gets
10190  // overwritten for each iteration of loop.
10191  if ( ifcell )
10192  {
10193  if ( temp_cell.elem( i ).is_string() )
10194  {
10195  str = temp_cell.elem( i ).string_value();
10196  // leave room for null termination.
10197  max_length = str.size() + 1;
10198  tmp_cstring = (char *) str.c_str();
10199  }
10200  else
10201  {
10202  // Use null string if user attempts to pass a cell array
10203  // with a non-string element (likely an empty element
10204  // since that should be allowed by the PLplot interface
10205  // if that element is going to be unused).
10206  // leave room for null termination.
10207  max_length = 1;
10208  tmp_cstring = (char *) "";
10209  }
10210  }
10211  else
10212  {
10213  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
10214  }
10215  arg3[i] = new char[max_length];
10216  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10217  arg3[i][max_length - 1] = '\0';
10218  // All the trailing blank crapola should not be needed for
10219  // string cell arrays.
10220  if ( !ifcell )
10221  {
10222  // remove trailing-blank padding that is used by the
10223  // charMatrix class to insure all strings in a given
10224  // charMatrix instance have the same length.
10225  // This transformation also removes legitimate trailing
10226  // blanks but there is nothing we can do about that
10227  // for the charMatrix class.
10228 
10229  // Look for trailing nulls first (just in case, although that
10230  // shouldn't happen if charMatrix implemented as documented)
10231  // before looking for trailing blanks.
10232  non_blank_length = max_length - 2;
10233  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10234  {
10235  non_blank_length--;
10236  }
10237  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10238  {
10239  non_blank_length--;
10240  }
10241  arg3[i][non_blank_length + 1] = '\0';
10242  }
10243  }
10244  }
10245  else
10246  {
10247  arg3 = NULL;
10248  }
10249  }
10250  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10251  _outv = octave_value();
10252  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10253  {
10254  delete [] arg2;
10255  }
10256  {
10257  int i;
10258  if ( arg3 != NULL )
10259  {
10260  for ( i = 0; i < Alen; i++ )
10261  {
10262  delete[] arg3[i];
10263  }
10264  delete[] arg3;
10265  }
10266  }
10267 fail:
10268  return _out;
10269 }
10270 
10271 
10273  int *arg1 = (int *) 0 ;
10274  int *arg2 = (int *) 0 ;
10275  int *arg3 = (int *) 0 ;
10276  char *arg4 = (char *) 0 ;
10277  int *arg5 = (int *) 0 ;
10278  int *arg6 = (int *) 0 ;
10279  PLFLT *arg7 = (PLFLT *) 0 ;
10280  PLFLT *arg8 = (PLFLT *) 0 ;
10281  PLFLT *arg9 = (PLFLT *) 0 ;
10282  PLFLT *arg10 = (PLFLT *) 0 ;
10283  int *arg11 = (int *) 0 ;
10284  int temp1 ;
10285  int res1 = SWIG_TMPOBJ ;
10286  int temp2 ;
10287  int res2 = SWIG_TMPOBJ ;
10288  int temp3 ;
10289  int res3 = SWIG_TMPOBJ ;
10290  octave_value_list retval4 ;
10291  int temp5 ;
10292  int res5 = SWIG_TMPOBJ ;
10293  int temp6 ;
10294  int res6 = SWIG_TMPOBJ ;
10295  PLFLT temp7 ;
10296  int res7 = SWIG_TMPOBJ ;
10297  PLFLT temp8 ;
10298  int res8 = SWIG_TMPOBJ ;
10299  PLFLT temp9 ;
10300  int res9 = SWIG_TMPOBJ ;
10301  PLFLT temp10 ;
10302  int res10 = SWIG_TMPOBJ ;
10303  int temp11 ;
10304  int res11 = SWIG_TMPOBJ ;
10305  octave_value_list _out;
10306  octave_value_list *_outp=&_out;
10307  octave_value _outv;
10308  int result;
10309 
10310  arg1 = &temp1;
10311  arg2 = &temp2;
10312  arg3 = &temp3;
10313  {
10314  // Check if version >= 3.4.0
10315 # if OCTAVE_API_VERSION_NUMBER < 45
10316  retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
10317 # else
10318  retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10319 # endif
10320  arg4 = (char *) retval4( 0 ).char_matrix_value().data();
10321  }
10322  arg5 = &temp5;
10323  arg6 = &temp6;
10324  arg7 = &temp7;
10325  arg8 = &temp8;
10326  arg9 = &temp9;
10327  arg10 = &temp10;
10328  arg11 = &temp11;
10329  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10330  SWIG_fail;
10331  }
10332  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10333  _outv = SWIG_From_int((int)(result));
10334  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10335  if (SWIG_IsTmpObj(res1)) {
10336  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10337  } else {
10338  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10339  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10340  }
10341  if (SWIG_IsTmpObj(res2)) {
10342  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10343  } else {
10344  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10345  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10346  }
10347  if (SWIG_IsTmpObj(res3)) {
10348  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10349  } else {
10350  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10351  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
10352  }
10353  {
10354  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
10355  }
10356  if (SWIG_IsTmpObj(res5)) {
10357  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
10358  } else {
10359  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10360  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
10361  }
10362  if (SWIG_IsTmpObj(res6)) {
10363  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
10364  } else {
10365  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10366  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
10367  }
10368  if (SWIG_IsTmpObj(res7)) {
10369  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
10370  } else {
10371  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10372  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
10373  }
10374  if (SWIG_IsTmpObj(res8)) {
10375  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
10376  } else {
10377  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10378  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
10379  }
10380  if (SWIG_IsTmpObj(res9)) {
10381  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
10382  } else {
10383  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10384  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
10385  }
10386  if (SWIG_IsTmpObj(res10)) {
10387  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
10388  } else {
10389  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10390  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
10391  }
10392  if (SWIG_IsTmpObj(res11)) {
10393  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
10394  } else {
10395  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10396  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
10397  }
10398 fail:
10399  return _out;
10400 }
10401 
10402 
10403 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
10404  PLFLT *arg1 = (PLFLT *) 0 ;
10405  PLFLT *arg2 = (PLFLT *) 0 ;
10406  PLFLT arg3 ;
10407  PLFLT arg4 ;
10408  PLFLT temp1 ;
10409  int res1 = SWIG_TMPOBJ ;
10410  PLFLT temp2 ;
10411  int res2 = SWIG_TMPOBJ ;
10412  double val3 ;
10413  int ecode3 = 0 ;
10414  double val4 ;
10415  int ecode4 = 0 ;
10416  octave_value_list _out;
10417  octave_value_list *_outp=&_out;
10418  octave_value _outv;
10419  int result;
10420 
10421  arg1 = &temp1;
10422  arg2 = &temp2;
10423  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
10424  SWIG_fail;
10425  }
10426  ecode3 = SWIG_AsVal_double(args(0), &val3);
10427  if (!SWIG_IsOK(ecode3)) {
10428  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
10429  }
10430  arg3 = (PLFLT)(val3);
10431  ecode4 = SWIG_AsVal_double(args(1), &val4);
10432  if (!SWIG_IsOK(ecode4)) {
10433  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
10434  }
10435  arg4 = (PLFLT)(val4);
10436  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
10437  _outv = SWIG_From_int((int)(result));
10438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10439  if (SWIG_IsTmpObj(res1)) {
10440  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
10441  } else {
10442  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10443  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10444  }
10445  if (SWIG_IsTmpObj(res2)) {
10446  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
10447  } else {
10448  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10449  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10450  }
10451 fail:
10452  return _out;
10453 }
10454 
10455 
10456 SWIG_DEFUN( plstripc, _wrap_plstripc, _wrap_plstripc_texinfo ) {
10457  PLINT *arg1 = (PLINT *) 0 ;
10458  char *arg2 = (char *) 0 ;
10459  char *arg3 = (char *) 0 ;
10460  PLFLT arg4 ;
10461  PLFLT arg5 ;
10462  PLFLT arg6 ;
10463  PLFLT arg7 ;
10464  PLFLT arg8 ;
10465  PLFLT arg9 ;
10466  PLFLT arg10 ;
10467  PLBOOL arg11 ;
10468  PLBOOL arg12 ;
10469  PLINT arg13 ;
10470  PLINT arg14 ;
10471  PLINT *arg15 = (PLINT *) 0 ;
10472  PLINT *arg16 = (PLINT *) 0 ;
10473  char *arg17 = (char *) 0 ;
10474  char *arg18 = (char *) 0 ;
10475  char *arg19 = (char *) 0 ;
10476  char *arg20 = (char *) 0 ;
10477  char *arg21 = (char *) 0 ;
10478  char *arg22 = (char *) 0 ;
10479  char *arg23 = (char *) 0 ;
10480  PLINT temp1 ;
10481  int res1 = SWIG_TMPOBJ ;
10482  int res2 ;
10483  char *buf2 = 0 ;
10484  int alloc2 = 0 ;
10485  int res3 ;
10486  char *buf3 = 0 ;
10487  int alloc3 = 0 ;
10488  double val4 ;
10489  int ecode4 = 0 ;
10490  double val5 ;
10491  int ecode5 = 0 ;
10492  double val6 ;
10493  int ecode6 = 0 ;
10494  double val7 ;
10495  int ecode7 = 0 ;
10496  double val8 ;
10497  int ecode8 = 0 ;
10498  double val9 ;
10499  int ecode9 = 0 ;
10500  double val10 ;
10501  int ecode10 = 0 ;
10502  int val11 ;
10503  int ecode11 = 0 ;
10504  int val12 ;
10505  int ecode12 = 0 ;
10506  int val13 ;
10507  int ecode13 = 0 ;
10508  int val14 ;
10509  int ecode14 = 0 ;
10510  Matrix temp15 ;
10511  Matrix temp16 ;
10512  int res17 ;
10513  char *buf17 = 0 ;
10514  int alloc17 = 0 ;
10515  int res18 ;
10516  char *buf18 = 0 ;
10517  int alloc18 = 0 ;
10518  int res19 ;
10519  char *buf19 = 0 ;
10520  int alloc19 = 0 ;
10521  int res20 ;
10522  char *buf20 = 0 ;
10523  int alloc20 = 0 ;
10524  int res21 ;
10525  char *buf21 = 0 ;
10526  int alloc21 = 0 ;
10527  int res22 ;
10528  char *buf22 = 0 ;
10529  int alloc22 = 0 ;
10530  int res23 ;
10531  char *buf23 = 0 ;
10532  int alloc23 = 0 ;
10533  octave_value_list _out;
10534  octave_value_list *_outp=&_out;
10535  octave_value _outv;
10536 
10537  arg1 = &temp1;
10538  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
10539  SWIG_fail;
10540  }
10541  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
10542  if (!SWIG_IsOK(res2)) {
10543  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
10544  }
10545  arg2 = (char *)(buf2);
10546  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
10547  if (!SWIG_IsOK(res3)) {
10548  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
10549  }
10550  arg3 = (char *)(buf3);
10551  ecode4 = SWIG_AsVal_double(args(2), &val4);
10552  if (!SWIG_IsOK(ecode4)) {
10553  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
10554  }
10555  arg4 = (PLFLT)(val4);
10556  ecode5 = SWIG_AsVal_double(args(3), &val5);
10557  if (!SWIG_IsOK(ecode5)) {
10558  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
10559  }
10560  arg5 = (PLFLT)(val5);
10561  ecode6 = SWIG_AsVal_double(args(4), &val6);
10562  if (!SWIG_IsOK(ecode6)) {
10563  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
10564  }
10565  arg6 = (PLFLT)(val6);
10566  ecode7 = SWIG_AsVal_double(args(5), &val7);
10567  if (!SWIG_IsOK(ecode7)) {
10568  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
10569  }
10570  arg7 = (PLFLT)(val7);
10571  ecode8 = SWIG_AsVal_double(args(6), &val8);
10572  if (!SWIG_IsOK(ecode8)) {
10573  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
10574  }
10575  arg8 = (PLFLT)(val8);
10576  ecode9 = SWIG_AsVal_double(args(7), &val9);
10577  if (!SWIG_IsOK(ecode9)) {
10578  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
10579  }
10580  arg9 = (PLFLT)(val9);
10581  ecode10 = SWIG_AsVal_double(args(8), &val10);
10582  if (!SWIG_IsOK(ecode10)) {
10583  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
10584  }
10585  arg10 = (PLFLT)(val10);
10586  ecode11 = SWIG_AsVal_int(args(9), &val11);
10587  if (!SWIG_IsOK(ecode11)) {
10588  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
10589  }
10590  arg11 = (PLBOOL)(val11);
10591  ecode12 = SWIG_AsVal_int(args(10), &val12);
10592  if (!SWIG_IsOK(ecode12)) {
10593  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
10594  }
10595  arg12 = (PLBOOL)(val12);
10596  ecode13 = SWIG_AsVal_int(args(11), &val13);
10597  if (!SWIG_IsOK(ecode13)) {
10598  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
10599  }
10600  arg13 = (PLINT)(val13);
10601  ecode14 = SWIG_AsVal_int(args(12), &val14);
10602  if (!SWIG_IsOK(ecode14)) {
10603  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
10604  }
10605  arg14 = (PLINT)(val14);
10606  {
10607  if ( _n_dims( args(13) ) > 1 )
10608  {
10609  error( "argument must be a scalar or vector" ); SWIG_fail;
10610  }
10611  Alen = (PLINT) ( _dim( args(13), 0 ) );
10612  temp15 = args(13).matrix_value();
10613  arg15 = new PLINT[Alen];
10614  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
10615  }
10616  {
10617  if ( _n_dims( args(14) ) > 1 )
10618  {
10619  error( "argument must be a scalar or vector" ); SWIG_fail;
10620  }
10621  if ( _dim( args(14), 0 ) != Alen )
10622  {
10623  error( "argument vectors must be same length" ); SWIG_fail;
10624  }
10625  temp16 = args(14).matrix_value();
10626  arg16 = new PLINT[Alen];
10627  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
10628  }
10629  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
10630  if (!SWIG_IsOK(res17)) {
10631  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
10632  }
10633  arg17 = (char *)(buf17);
10634  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
10635  if (!SWIG_IsOK(res18)) {
10636  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
10637  }
10638  arg18 = (char *)(buf18);
10639  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
10640  if (!SWIG_IsOK(res19)) {
10641  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
10642  }
10643  arg19 = (char *)(buf19);
10644  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
10645  if (!SWIG_IsOK(res20)) {
10646  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
10647  }
10648  arg20 = (char *)(buf20);
10649  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
10650  if (!SWIG_IsOK(res21)) {
10651  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
10652  }
10653  arg21 = (char *)(buf21);
10654  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
10655  if (!SWIG_IsOK(res22)) {
10656  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
10657  }
10658  arg22 = (char *)(buf22);
10659  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
10660  if (!SWIG_IsOK(res23)) {
10661  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
10662  }
10663  arg23 = (char *)(buf23);
10664  my_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,(char const *)arg21,(char const *)arg22,(char const *)arg23);
10665  _outv = octave_value();
10666  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10667  if (SWIG_IsTmpObj(res1)) {
10668  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10669  } else {
10670  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10671  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10672  }
10673  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10674  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10675  {
10676  delete [] arg15;
10677  }
10678  {
10679  delete [] arg16;
10680  }
10681  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
10682  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
10683  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
10684  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
10685  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
10686  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
10687  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
10688 fail:
10689  return _out;
10690 }
10691 
10692 
10693 SWIG_DEFUN( plcont, _wrap_plcont, _wrap_plcont_texinfo ) {
10694  PLFLT *arg1 = (PLFLT *) 0 ;
10695  PLINT arg2 ;
10696  PLINT arg3 ;
10697  PLINT arg4 ;
10698  PLINT arg5 ;
10699  PLINT arg6 ;
10700  PLINT arg7 ;
10701  PLFLT *arg8 = (PLFLT *) 0 ;
10702  PLINT arg9 ;
10703  PLFLT *arg10 = (PLFLT *) 0 ;
10704  Matrix temp1 ;
10705  int val4 ;
10706  int ecode4 = 0 ;
10707  int val5 ;
10708  int ecode5 = 0 ;
10709  int val6 ;
10710  int ecode6 = 0 ;
10711  int val7 ;
10712  int ecode7 = 0 ;
10713  Matrix temp8 ;
10714  Matrix temp10 ;
10715  octave_value_list _out;
10716  octave_value_list *_outp=&_out;
10717  octave_value _outv;
10718 
10719  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
10720  SWIG_fail;
10721  }
10722  {
10723  if ( _n_dims( args(0) ) > 2 )
10724  {
10725  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10726  }
10727  temp1 = args(0).matrix_value();
10728  arg1 = &temp1( 0, 0 );
10729  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10730  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10731  }
10732  ecode4 = SWIG_AsVal_int(args(1), &val4);
10733  if (!SWIG_IsOK(ecode4)) {
10734  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
10735  }
10736  arg4 = (PLINT)(val4);
10737  ecode5 = SWIG_AsVal_int(args(2), &val5);
10738  if (!SWIG_IsOK(ecode5)) {
10739  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
10740  }
10741  arg5 = (PLINT)(val5);
10742  ecode6 = SWIG_AsVal_int(args(3), &val6);
10743  if (!SWIG_IsOK(ecode6)) {
10744  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
10745  }
10746  arg6 = (PLINT)(val6);
10747  ecode7 = SWIG_AsVal_int(args(4), &val7);
10748  if (!SWIG_IsOK(ecode7)) {
10749  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
10750  }
10751  arg7 = (PLINT)(val7);
10752  {
10753  if ( _n_dims( args(5) ) > 1 )
10754  {
10755  error( "argument must be a scalar or vector" ); SWIG_fail;
10756  }
10757  temp8 = args(5).matrix_value();
10758  arg8 = &temp8( 0, 0 );
10759  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10760  }
10761  {
10762  if ( _n_dims( args(6) ) > 1 )
10763  {
10764  error( "argument must be a scalar or vector" ); SWIG_fail;
10765  }
10766  if ( _dim( args(6), 0 ) != 6 )
10767  {
10768  error( "argument vectors must have length of 6" ); SWIG_fail;
10769  }
10770  temp10 = args(6).matrix_value();
10771  arg10 = &temp10( 0, 0 );
10772  }
10773  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
10774  _outv = octave_value();
10775  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10776  {
10777 
10778  }
10779  {
10780 
10781  }
10782  {
10783 
10784  }
10785 fail:
10786  return _out;
10787 }
10788 
10789 
10790 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
10791  PLFLT *arg1 = (PLFLT *) 0 ;
10792  PLINT arg2 ;
10793  PLINT arg3 ;
10794  PLINT arg4 ;
10795  PLINT arg5 ;
10796  PLINT arg6 ;
10797  PLINT arg7 ;
10798  PLFLT *arg8 = (PLFLT *) 0 ;
10799  PLINT arg9 ;
10800  Matrix temp1 ;
10801  int val4 ;
10802  int ecode4 = 0 ;
10803  int val5 ;
10804  int ecode5 = 0 ;
10805  int val6 ;
10806  int ecode6 = 0 ;
10807  int val7 ;
10808  int ecode7 = 0 ;
10809  Matrix temp8 ;
10810  octave_value_list _out;
10811  octave_value_list *_outp=&_out;
10812  octave_value _outv;
10813 
10814  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
10815  SWIG_fail;
10816  }
10817  {
10818  if ( _n_dims( args(0) ) > 2 )
10819  {
10820  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10821  }
10822  temp1 = args(0).matrix_value();
10823  arg1 = &temp1( 0, 0 );
10824  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10825  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10826  }
10827  ecode4 = SWIG_AsVal_int(args(1), &val4);
10828  if (!SWIG_IsOK(ecode4)) {
10829  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
10830  }
10831  arg4 = (PLINT)(val4);
10832  ecode5 = SWIG_AsVal_int(args(2), &val5);
10833  if (!SWIG_IsOK(ecode5)) {
10834  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
10835  }
10836  arg5 = (PLINT)(val5);
10837  ecode6 = SWIG_AsVal_int(args(3), &val6);
10838  if (!SWIG_IsOK(ecode6)) {
10839  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
10840  }
10841  arg6 = (PLINT)(val6);
10842  ecode7 = SWIG_AsVal_int(args(4), &val7);
10843  if (!SWIG_IsOK(ecode7)) {
10844  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
10845  }
10846  arg7 = (PLINT)(val7);
10847  {
10848  if ( _n_dims( args(5) ) > 1 )
10849  {
10850  error( "argument must be a scalar or vector" ); SWIG_fail;
10851  }
10852  temp8 = args(5).matrix_value();
10853  arg8 = &temp8( 0, 0 );
10854  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10855  }
10856  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
10857  _outv = octave_value();
10858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10859  {
10860 
10861  }
10862  {
10863 
10864  }
10865 fail:
10866  return _out;
10867 }
10868 
10869 
10870 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
10871  PLFLT *arg1 = (PLFLT *) 0 ;
10872  PLINT arg2 ;
10873  PLINT arg3 ;
10874  PLINT arg4 ;
10875  PLINT arg5 ;
10876  PLINT arg6 ;
10877  PLINT arg7 ;
10878  PLFLT *arg8 = (PLFLT *) 0 ;
10879  PLINT arg9 ;
10880  PLFLT *arg10 = (PLFLT *) 0 ;
10881  PLFLT *arg11 = (PLFLT *) 0 ;
10882  Matrix temp1 ;
10883  int val4 ;
10884  int ecode4 = 0 ;
10885  int val5 ;
10886  int ecode5 = 0 ;
10887  int val6 ;
10888  int ecode6 = 0 ;
10889  int val7 ;
10890  int ecode7 = 0 ;
10891  Matrix temp8 ;
10892  Matrix temp10 ;
10893  Matrix temp11 ;
10894  octave_value_list _out;
10895  octave_value_list *_outp=&_out;
10896  octave_value _outv;
10897 
10898  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
10899  SWIG_fail;
10900  }
10901  {
10902  if ( _n_dims( args(0) ) > 2 )
10903  {
10904  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10905  }
10906  temp1 = args(0).matrix_value();
10907  arg1 = &temp1( 0, 0 );
10908  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10909  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10910  }
10911  ecode4 = SWIG_AsVal_int(args(1), &val4);
10912  if (!SWIG_IsOK(ecode4)) {
10913  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
10914  }
10915  arg4 = (PLINT)(val4);
10916  ecode5 = SWIG_AsVal_int(args(2), &val5);
10917  if (!SWIG_IsOK(ecode5)) {
10918  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
10919  }
10920  arg5 = (PLINT)(val5);
10921  ecode6 = SWIG_AsVal_int(args(3), &val6);
10922  if (!SWIG_IsOK(ecode6)) {
10923  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
10924  }
10925  arg6 = (PLINT)(val6);
10926  ecode7 = SWIG_AsVal_int(args(4), &val7);
10927  if (!SWIG_IsOK(ecode7)) {
10928  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
10929  }
10930  arg7 = (PLINT)(val7);
10931  {
10932  if ( _n_dims( args(5) ) > 1 )
10933  {
10934  error( "argument must be a scalar or vector" ); SWIG_fail;
10935  }
10936  temp8 = args(5).matrix_value();
10937  arg8 = &temp8( 0, 0 );
10938  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10939  }
10940  {
10941  if ( _n_dims( args(6) ) > 1 )
10942  {
10943  error( "argument must be a scalar or vector" ); SWIG_fail;
10944  }
10945  if ( _dim( args(6), 0 ) != Xlen )
10946  {
10947  error( "argument vectors must be same length" ); SWIG_fail;
10948  }
10949  temp10 = args(6).matrix_value();
10950  arg10 = &temp10( 0, 0 );
10951  }
10952  {
10953  if ( _n_dims( args(7) ) > 1 )
10954  {
10955  error( "argument must be a scalar or vector" ); SWIG_fail;
10956  }
10957  if ( _dim( args(7), 0 ) != Ylen )
10958  {
10959  error( "argument vectors must be same length" ); SWIG_fail;
10960  }
10961  temp11 = args(7).matrix_value();
10962  arg11 = &temp11( 0, 0 );
10963  }
10964  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
10965  _outv = octave_value();
10966  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10967  {
10968 
10969  }
10970  {
10971 
10972  }
10973  {
10974 
10975  }
10976  {
10977 
10978  }
10979 fail:
10980  return _out;
10981 }
10982 
10983 
10984 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
10985  PLFLT *arg1 = (PLFLT *) 0 ;
10986  PLINT arg2 ;
10987  PLINT arg3 ;
10988  PLINT arg4 ;
10989  PLINT arg5 ;
10990  PLINT arg6 ;
10991  PLINT arg7 ;
10992  PLFLT *arg8 = (PLFLT *) 0 ;
10993  PLINT arg9 ;
10994  PLFLT *arg10 = (PLFLT *) 0 ;
10995  PLFLT *arg11 = (PLFLT *) 0 ;
10996  Matrix temp1 ;
10997  int val4 ;
10998  int ecode4 = 0 ;
10999  int val5 ;
11000  int ecode5 = 0 ;
11001  int val6 ;
11002  int ecode6 = 0 ;
11003  int val7 ;
11004  int ecode7 = 0 ;
11005  Matrix temp8 ;
11006  Matrix temp10 ;
11007  Matrix temp11 ;
11008  octave_value_list _out;
11009  octave_value_list *_outp=&_out;
11010  octave_value _outv;
11011 
11012  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11013  SWIG_fail;
11014  }
11015  {
11016  if ( _n_dims( args(0) ) > 2 )
11017  {
11018  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11019  }
11020  temp1 = args(0).matrix_value();
11021  arg1 = &temp1( 0, 0 );
11022  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11023  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11024  }
11025  ecode4 = SWIG_AsVal_int(args(1), &val4);
11026  if (!SWIG_IsOK(ecode4)) {
11027  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11028  }
11029  arg4 = (PLINT)(val4);
11030  ecode5 = SWIG_AsVal_int(args(2), &val5);
11031  if (!SWIG_IsOK(ecode5)) {
11032  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11033  }
11034  arg5 = (PLINT)(val5);
11035  ecode6 = SWIG_AsVal_int(args(3), &val6);
11036  if (!SWIG_IsOK(ecode6)) {
11037  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11038  }
11039  arg6 = (PLINT)(val6);
11040  ecode7 = SWIG_AsVal_int(args(4), &val7);
11041  if (!SWIG_IsOK(ecode7)) {
11042  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11043  }
11044  arg7 = (PLINT)(val7);
11045  {
11046  if ( _n_dims( args(5) ) > 1 )
11047  {
11048  error( "argument must be a scalar or vector" ); SWIG_fail;
11049  }
11050  temp8 = args(5).matrix_value();
11051  arg8 = &temp8( 0, 0 );
11052  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11053  }
11054  {
11055  if ( _n_dims( args(6) ) > 2 )
11056  {
11057  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11058  }
11059  if ( _dim( args(6), 0 ) != Xlen )
11060  {
11061  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11062  }
11063  if ( _dim( args(6), 1 ) != Ylen )
11064  {
11065  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11066  }
11067  temp10 = args(6).matrix_value();
11068  arg10 = &temp10( 0, 0 );
11069  }
11070  {
11071  if ( _n_dims( args(7) ) > 2 )
11072  {
11073  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11074  }
11075  if ( _dim( args(7), 0 ) != Xlen )
11076  {
11077  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11078  }
11079  if ( _dim( args(7), 1 ) != Ylen )
11080  {
11081  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11082  }
11083  temp11 = args(7).matrix_value();
11084  arg11 = &temp11( 0, 0 );
11085  }
11086  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11087  _outv = octave_value();
11088  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11089  {
11090 
11091  }
11092  {
11093 
11094  }
11095  {
11096 
11097  }
11098  {
11099 
11100  }
11101 fail:
11102  return _out;
11103 }
11104 
11105 
11106 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11107  PLFLT *arg1 = (PLFLT *) 0 ;
11108  PLINT arg2 ;
11109  PLINT arg3 ;
11110  PLINT arg4 ;
11111  PLINT arg5 ;
11112  PLINT arg6 ;
11113  PLINT arg7 ;
11114  PLFLT *arg8 = (PLFLT *) 0 ;
11115  PLINT arg9 ;
11116  PLFLT *arg10 = (PLFLT *) 0 ;
11117  PLFLT *arg11 = (PLFLT *) 0 ;
11118  Matrix temp1 ;
11119  int val4 ;
11120  int ecode4 = 0 ;
11121  int val5 ;
11122  int ecode5 = 0 ;
11123  int val6 ;
11124  int ecode6 = 0 ;
11125  int val7 ;
11126  int ecode7 = 0 ;
11127  Matrix temp8 ;
11128  Matrix temp10 ;
11129  Matrix temp11 ;
11130  octave_value_list _out;
11131  octave_value_list *_outp=&_out;
11132  octave_value _outv;
11133 
11134  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11135  SWIG_fail;
11136  }
11137  {
11138  if ( _n_dims( args(0) ) > 2 )
11139  {
11140  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11141  }
11142  temp1 = args(0).matrix_value();
11143  arg1 = &temp1( 0, 0 );
11144  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11145  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11146  }
11147  ecode4 = SWIG_AsVal_int(args(1), &val4);
11148  if (!SWIG_IsOK(ecode4)) {
11149  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11150  }
11151  arg4 = (PLINT)(val4);
11152  ecode5 = SWIG_AsVal_int(args(2), &val5);
11153  if (!SWIG_IsOK(ecode5)) {
11154  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11155  }
11156  arg5 = (PLINT)(val5);
11157  ecode6 = SWIG_AsVal_int(args(3), &val6);
11158  if (!SWIG_IsOK(ecode6)) {
11159  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11160  }
11161  arg6 = (PLINT)(val6);
11162  ecode7 = SWIG_AsVal_int(args(4), &val7);
11163  if (!SWIG_IsOK(ecode7)) {
11164  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11165  }
11166  arg7 = (PLINT)(val7);
11167  {
11168  if ( _n_dims( args(5) ) > 1 )
11169  {
11170  error( "argument must be a scalar or vector" ); SWIG_fail;
11171  }
11172  temp8 = args(5).matrix_value();
11173  arg8 = &temp8( 0, 0 );
11174  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11175  }
11176  {
11177  if ( _n_dims( args(6) ) > 2 )
11178  {
11179  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11180  }
11181  if ( _dim( args(6), 0 ) != Xlen )
11182  {
11183  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11184  }
11185  if ( _dim( args(6), 1 ) != Ylen )
11186  {
11187  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11188  }
11189  temp10 = args(6).matrix_value();
11190  arg10 = &temp10( 0, 0 );
11191  }
11192  {
11193  if ( _n_dims( args(7) ) > 2 )
11194  {
11195  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11196  }
11197  if ( _dim( args(7), 0 ) != Xlen )
11198  {
11199  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11200  }
11201  if ( _dim( args(7), 1 ) != Ylen )
11202  {
11203  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11204  }
11205  temp11 = args(7).matrix_value();
11206  arg11 = &temp11( 0, 0 );
11207  }
11208  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11209  _outv = octave_value();
11210  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11211  {
11212 
11213  }
11214  {
11215 
11216  }
11217  {
11218 
11219  }
11220  {
11221 
11222  }
11223 fail:
11224  return _out;
11225 }
11226 
11227 
11228 SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
11229  PLFLT *arg1 = (PLFLT *) 0 ;
11230  PLFLT *arg2 = (PLFLT *) 0 ;
11231  PLFLT *arg3 = (PLFLT *) 0 ;
11232  PLINT arg4 ;
11233  PLFLT *arg5 = (PLFLT *) 0 ;
11234  PLINT arg6 ;
11235  PLFLT *arg7 = (PLFLT *) 0 ;
11236  PLINT arg8 ;
11237  PLFLT *arg9 = (PLFLT *) 0 ;
11238  PLINT arg10 ;
11239  PLFLT arg11 ;
11240  Matrix temp1 ;
11241  Matrix temp2 ;
11242  Matrix temp3 ;
11243  Matrix temp5 ;
11244  Matrix temp7 ;
11245  octave_value_list retval7 ;
11246  int val10 ;
11247  int ecode10 = 0 ;
11248  double val11 ;
11249  int ecode11 = 0 ;
11250  octave_value_list _out;
11251  octave_value_list *_outp=&_out;
11252  octave_value _outv;
11253 
11254  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11255  SWIG_fail;
11256  }
11257  {
11258  if ( _n_dims( args(0) ) > 1 )
11259  {
11260  error( "argument must be a scalar or vector" ); SWIG_fail;
11261  }
11262  Alen = (PLINT) ( _dim( args(0), 0 ) );
11263  temp1 = args(0).matrix_value();
11264  arg1 = &temp1( 0, 0 );
11265  }
11266  {
11267  if ( _n_dims( args(1) ) > 1 )
11268  {
11269  error( "argument must be a scalar or vector" ); SWIG_fail;
11270  }
11271  if ( _dim( args(1), 0 ) != Alen )
11272  {
11273  error( "argument vectors must be same length" ); SWIG_fail;
11274  }
11275  temp2 = args(1).matrix_value();
11276  arg2 = &temp2( 0, 0 );
11277  }
11278  {
11279  if ( _n_dims( args(2) ) > 1 )
11280  {
11281  error( "argument must be a scalar or vector" ); SWIG_fail;
11282  }
11283  if ( _dim( args(2), 0 ) != Alen )
11284  {
11285  error( "argument vectors must be same length" ); SWIG_fail;
11286  }
11287  temp3 = args(2).matrix_value();
11288  arg3 = &temp3( 0, 0 );
11289  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11290  }
11291  {
11292  if ( _n_dims( args(3) ) > 1 )
11293  {
11294  error( "argument must be a scalar or vector" ); SWIG_fail;
11295  }
11296  temp5 = args(3).matrix_value();
11297  arg5 = &temp5( 0, 0 );
11298  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
11299  }
11300  {
11301  if ( _n_dims( args(4) ) > 1 )
11302  {
11303  error( "argument must be a scalar or vector" ); SWIG_fail;
11304  }
11305  temp7 = args(4).matrix_value();
11306  arg7 = &temp7( 0, 0 );
11307  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
11308  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
11309  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11310  }
11311  ecode10 = SWIG_AsVal_int(args(5), &val10);
11312  if (!SWIG_IsOK(ecode10)) {
11313  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
11314  }
11315  arg10 = (PLINT)(val10);
11316  ecode11 = SWIG_AsVal_double(args(6), &val11);
11317  if (!SWIG_IsOK(ecode11)) {
11318  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
11319  }
11320  arg11 = (PLFLT)(val11);
11321  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
11322  _outv = octave_value();
11323  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11324  {
11325  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
11326  }
11327  {
11328 
11329  }
11330  {
11331 
11332  }
11333  {
11334 
11335  }
11336  {
11337 
11338  }
11339  {
11340 
11341  }
11342 fail:
11343  return _out;
11344 }
11345 
11346 
11347 SWIG_DEFUN( plmesh, _wrap_plmesh, _wrap_plmesh_texinfo ) {
11348  PLFLT *arg1 = (PLFLT *) 0 ;
11349  PLFLT *arg2 = (PLFLT *) 0 ;
11350  PLFLT *arg3 = (PLFLT *) 0 ;
11351  PLINT arg4 ;
11352  PLINT arg5 ;
11353  PLINT arg6 ;
11354  Matrix temp1 ;
11355  Matrix temp2 ;
11356  Matrix temp3 ;
11357  int val6 ;
11358  int ecode6 = 0 ;
11359  octave_value_list _out;
11360  octave_value_list *_outp=&_out;
11361  octave_value _outv;
11362 
11363  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
11364  SWIG_fail;
11365  }
11366  {
11367  if ( _n_dims( args(0) ) > 1 )
11368  {
11369  error( "argument must be a scalar or vector" ); SWIG_fail;
11370  }
11371  temp1 = args(0).matrix_value();
11372  arg1 = &temp1( 0, 0 );
11373  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11374  }
11375  {
11376  if ( _n_dims( args(1) ) > 1 )
11377  {
11378  error( "argument must be a scalar or vector" ); SWIG_fail;
11379  }
11380  temp2 = args(1).matrix_value();
11381  arg2 = &temp2( 0, 0 );
11382  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11383  }
11384  {
11385  if ( _n_dims( args(2) ) > 2 )
11386  {
11387  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11388  }
11389  if ( _dim( args(2), 0 ) != Xlen )
11390  {
11391  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11392  }
11393  if ( _dim( args(2), 1 ) != Ylen )
11394  {
11395  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11396  }
11397  temp3 = args(2).matrix_value();
11398  arg3 = &temp3( 0, 0 );
11399  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11400  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11401  }
11402  ecode6 = SWIG_AsVal_int(args(3), &val6);
11403  if (!SWIG_IsOK(ecode6)) {
11404  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
11405  }
11406  arg6 = (PLINT)(val6);
11407  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
11408  _outv = octave_value();
11409  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11410  {
11411 
11412  }
11413  {
11414 
11415  }
11416  {
11417 
11418  }
11419 fail:
11420  return _out;
11421 }
11422 
11423 
11424 SWIG_DEFUN( plmeshc, _wrap_plmeshc, _wrap_plmeshc_texinfo ) {
11425  PLFLT *arg1 = (PLFLT *) 0 ;
11426  PLFLT *arg2 = (PLFLT *) 0 ;
11427  PLFLT *arg3 = (PLFLT *) 0 ;
11428  PLINT arg4 ;
11429  PLINT arg5 ;
11430  PLINT arg6 ;
11431  PLFLT *arg7 = (PLFLT *) 0 ;
11432  PLINT arg8 ;
11433  Matrix temp1 ;
11434  Matrix temp2 ;
11435  Matrix temp3 ;
11436  int val6 ;
11437  int ecode6 = 0 ;
11438  Matrix temp7 ;
11439  octave_value_list _out;
11440  octave_value_list *_outp=&_out;
11441  octave_value _outv;
11442 
11443  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
11444  SWIG_fail;
11445  }
11446  {
11447  if ( _n_dims( args(0) ) > 1 )
11448  {
11449  error( "argument must be a scalar or vector" ); SWIG_fail;
11450  }
11451  temp1 = args(0).matrix_value();
11452  arg1 = &temp1( 0, 0 );
11453  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11454  }
11455  {
11456  if ( _n_dims( args(1) ) > 1 )
11457  {
11458  error( "argument must be a scalar or vector" ); SWIG_fail;
11459  }
11460  temp2 = args(1).matrix_value();
11461  arg2 = &temp2( 0, 0 );
11462  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11463  }
11464  {
11465  if ( _n_dims( args(2) ) > 2 )
11466  {
11467  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11468  }
11469  if ( _dim( args(2), 0 ) != Xlen )
11470  {
11471  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11472  }
11473  if ( _dim( args(2), 1 ) != Ylen )
11474  {
11475  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11476  }
11477  temp3 = args(2).matrix_value();
11478  arg3 = &temp3( 0, 0 );
11479  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11480  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11481  }
11482  ecode6 = SWIG_AsVal_int(args(3), &val6);
11483  if (!SWIG_IsOK(ecode6)) {
11484  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
11485  }
11486  arg6 = (PLINT)(val6);
11487  {
11488  if ( _n_dims( args(4) ) > 1 )
11489  {
11490  error( "argument must be a scalar or vector" ); SWIG_fail;
11491  }
11492  temp7 = args(4).matrix_value();
11493  arg7 = &temp7( 0, 0 );
11494  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11495  }
11496  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11497  _outv = octave_value();
11498  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11499  {
11500 
11501  }
11502  {
11503 
11504  }
11505  {
11506 
11507  }
11508  {
11509 
11510  }
11511 fail:
11512  return _out;
11513 }
11514 
11515 
11516 SWIG_DEFUN( plot3d, _wrap_plot3d, _wrap_plot3d_texinfo ) {
11517  PLFLT *arg1 = (PLFLT *) 0 ;
11518  PLFLT *arg2 = (PLFLT *) 0 ;
11519  PLFLT *arg3 = (PLFLT *) 0 ;
11520  PLINT arg4 ;
11521  PLINT arg5 ;
11522  PLINT arg6 ;
11523  PLBOOL arg7 ;
11524  Matrix temp1 ;
11525  Matrix temp2 ;
11526  Matrix temp3 ;
11527  int val6 ;
11528  int ecode6 = 0 ;
11529  int val7 ;
11530  int ecode7 = 0 ;
11531  octave_value_list _out;
11532  octave_value_list *_outp=&_out;
11533  octave_value _outv;
11534 
11535  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
11536  SWIG_fail;
11537  }
11538  {
11539  if ( _n_dims( args(0) ) > 1 )
11540  {
11541  error( "argument must be a scalar or vector" ); SWIG_fail;
11542  }
11543  temp1 = args(0).matrix_value();
11544  arg1 = &temp1( 0, 0 );
11545  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11546  }
11547  {
11548  if ( _n_dims( args(1) ) > 1 )
11549  {
11550  error( "argument must be a scalar or vector" ); SWIG_fail;
11551  }
11552  temp2 = args(1).matrix_value();
11553  arg2 = &temp2( 0, 0 );
11554  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11555  }
11556  {
11557  if ( _n_dims( args(2) ) > 2 )
11558  {
11559  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11560  }
11561  if ( _dim( args(2), 0 ) != Xlen )
11562  {
11563  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11564  }
11565  if ( _dim( args(2), 1 ) != Ylen )
11566  {
11567  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11568  }
11569  temp3 = args(2).matrix_value();
11570  arg3 = &temp3( 0, 0 );
11571  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11572  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11573  }
11574  ecode6 = SWIG_AsVal_int(args(3), &val6);
11575  if (!SWIG_IsOK(ecode6)) {
11576  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
11577  }
11578  arg6 = (PLINT)(val6);
11579  ecode7 = SWIG_AsVal_int(args(4), &val7);
11580  if (!SWIG_IsOK(ecode7)) {
11581  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
11582  }
11583  arg7 = (PLBOOL)(val7);
11584  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
11585  _outv = octave_value();
11586  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11587  {
11588 
11589  }
11590  {
11591 
11592  }
11593  {
11594 
11595  }
11596 fail:
11597  return _out;
11598 }
11599 
11600 
11601 SWIG_DEFUN( plot3dc, _wrap_plot3dc, _wrap_plot3dc_texinfo ) {
11602  PLFLT *arg1 = (PLFLT *) 0 ;
11603  PLFLT *arg2 = (PLFLT *) 0 ;
11604  PLFLT *arg3 = (PLFLT *) 0 ;
11605  PLINT arg4 ;
11606  PLINT arg5 ;
11607  PLINT arg6 ;
11608  PLFLT *arg7 = (PLFLT *) 0 ;
11609  PLINT arg8 ;
11610  Matrix temp1 ;
11611  Matrix temp2 ;
11612  Matrix temp3 ;
11613  int val6 ;
11614  int ecode6 = 0 ;
11615  Matrix temp7 ;
11616  octave_value_list _out;
11617  octave_value_list *_outp=&_out;
11618  octave_value _outv;
11619 
11620  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
11621  SWIG_fail;
11622  }
11623  {
11624  if ( _n_dims( args(0) ) > 1 )
11625  {
11626  error( "argument must be a scalar or vector" ); SWIG_fail;
11627  }
11628  temp1 = args(0).matrix_value();
11629  arg1 = &temp1( 0, 0 );
11630  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11631  }
11632  {
11633  if ( _n_dims( args(1) ) > 1 )
11634  {
11635  error( "argument must be a scalar or vector" ); SWIG_fail;
11636  }
11637  temp2 = args(1).matrix_value();
11638  arg2 = &temp2( 0, 0 );
11639  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11640  }
11641  {
11642  if ( _n_dims( args(2) ) > 2 )
11643  {
11644  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11645  }
11646  if ( _dim( args(2), 0 ) != Xlen )
11647  {
11648  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11649  }
11650  if ( _dim( args(2), 1 ) != Ylen )
11651  {
11652  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11653  }
11654  temp3 = args(2).matrix_value();
11655  arg3 = &temp3( 0, 0 );
11656  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11657  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11658  }
11659  ecode6 = SWIG_AsVal_int(args(3), &val6);
11660  if (!SWIG_IsOK(ecode6)) {
11661  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
11662  }
11663  arg6 = (PLINT)(val6);
11664  {
11665  if ( _n_dims( args(4) ) > 1 )
11666  {
11667  error( "argument must be a scalar or vector" ); SWIG_fail;
11668  }
11669  temp7 = args(4).matrix_value();
11670  arg7 = &temp7( 0, 0 );
11671  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11672  }
11673  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11674  _outv = octave_value();
11675  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11676  {
11677 
11678  }
11679  {
11680 
11681  }
11682  {
11683 
11684  }
11685  {
11686 
11687  }
11688 fail:
11689  return _out;
11690 }
11691 
11692 
11693 SWIG_DEFUN( plot3dcl, _wrap_plot3dcl, _wrap_plot3dcl_texinfo ) {
11694  PLFLT *arg1 = (PLFLT *) 0 ;
11695  PLFLT *arg2 = (PLFLT *) 0 ;
11696  PLFLT *arg3 = (PLFLT *) 0 ;
11697  PLINT arg4 ;
11698  PLINT arg5 ;
11699  PLINT arg6 ;
11700  PLFLT *arg7 = (PLFLT *) 0 ;
11701  PLINT arg8 ;
11702  PLINT arg9 ;
11703  PLINT arg10 ;
11704  PLINT *arg11 = (PLINT *) 0 ;
11705  PLINT *arg12 = (PLINT *) 0 ;
11706  Matrix temp1 ;
11707  Matrix temp2 ;
11708  Matrix temp3 ;
11709  int val6 ;
11710  int ecode6 = 0 ;
11711  Matrix temp7 ;
11712  int val9 ;
11713  int ecode9 = 0 ;
11714  Matrix temp10 ;
11715  Matrix temp12 ;
11716  octave_value_list _out;
11717  octave_value_list *_outp=&_out;
11718  octave_value _outv;
11719 
11720  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
11721  SWIG_fail;
11722  }
11723  {
11724  if ( _n_dims( args(0) ) > 1 )
11725  {
11726  error( "argument must be a scalar or vector" ); SWIG_fail;
11727  }
11728  temp1 = args(0).matrix_value();
11729  arg1 = &temp1( 0, 0 );
11730  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11731  }
11732  {
11733  if ( _n_dims( args(1) ) > 1 )
11734  {
11735  error( "argument must be a scalar or vector" ); SWIG_fail;
11736  }
11737  temp2 = args(1).matrix_value();
11738  arg2 = &temp2( 0, 0 );
11739  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11740  }
11741  {
11742  if ( _n_dims( args(2) ) > 2 )
11743  {
11744  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11745  }
11746  if ( _dim( args(2), 0 ) != Xlen )
11747  {
11748  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11749  }
11750  if ( _dim( args(2), 1 ) != Ylen )
11751  {
11752  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11753  }
11754  temp3 = args(2).matrix_value();
11755  arg3 = &temp3( 0, 0 );
11756  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11757  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11758  }
11759  ecode6 = SWIG_AsVal_int(args(3), &val6);
11760  if (!SWIG_IsOK(ecode6)) {
11761  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
11762  }
11763  arg6 = (PLINT)(val6);
11764  {
11765  if ( _n_dims( args(4) ) > 1 )
11766  {
11767  error( "argument must be a scalar or vector" ); SWIG_fail;
11768  }
11769  temp7 = args(4).matrix_value();
11770  arg7 = &temp7( 0, 0 );
11771  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11772  }
11773  ecode9 = SWIG_AsVal_int(args(5), &val9);
11774  if (!SWIG_IsOK(ecode9)) {
11775  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
11776  }
11777  arg9 = (PLINT)(val9);
11778  {
11779  if ( _n_dims( args(6) ) > 1 )
11780  {
11781  error( "argument must be a scalar or vector" ); SWIG_fail;
11782  }
11783  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
11784  arg11 = new PLINT[Alen];
11785  temp10 = args(6).matrix_value();
11786  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
11787  }
11788  {
11789  if ( _n_dims( args(7) ) > 1 )
11790  {
11791  error( "argument must be a scalar or vector" ); SWIG_fail;
11792  }
11793  if ( _dim( args(7), 0 ) != Alen )
11794  {
11795  error( "argument vectors must be same length" ); SWIG_fail;
11796  }
11797  temp12 = args(7).matrix_value();
11798  arg12 = new PLINT[Alen];
11799  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
11800  }
11801  my_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);
11802  _outv = octave_value();
11803  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11804  {
11805 
11806  }
11807  {
11808 
11809  }
11810  {
11811 
11812  }
11813  {
11814 
11815  }
11816  {
11817  delete [] arg11;
11818  }
11819  {
11820  delete [] arg12;
11821  }
11822 fail:
11823  return _out;
11824 }
11825 
11826 
11827 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, _wrap_plsurf3d_texinfo ) {
11828  PLFLT *arg1 = (PLFLT *) 0 ;
11829  PLFLT *arg2 = (PLFLT *) 0 ;
11830  PLFLT *arg3 = (PLFLT *) 0 ;
11831  PLINT arg4 ;
11832  PLINT arg5 ;
11833  PLINT arg6 ;
11834  PLFLT *arg7 = (PLFLT *) 0 ;
11835  PLINT arg8 ;
11836  Matrix temp1 ;
11837  Matrix temp2 ;
11838  Matrix temp3 ;
11839  int val6 ;
11840  int ecode6 = 0 ;
11841  Matrix temp7 ;
11842  octave_value_list _out;
11843  octave_value_list *_outp=&_out;
11844  octave_value _outv;
11845 
11846  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
11847  SWIG_fail;
11848  }
11849  {
11850  if ( _n_dims( args(0) ) > 1 )
11851  {
11852  error( "argument must be a scalar or vector" ); SWIG_fail;
11853  }
11854  temp1 = args(0).matrix_value();
11855  arg1 = &temp1( 0, 0 );
11856  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11857  }
11858  {
11859  if ( _n_dims( args(1) ) > 1 )
11860  {
11861  error( "argument must be a scalar or vector" ); SWIG_fail;
11862  }
11863  temp2 = args(1).matrix_value();
11864  arg2 = &temp2( 0, 0 );
11865  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11866  }
11867  {
11868  if ( _n_dims( args(2) ) > 2 )
11869  {
11870  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11871  }
11872  if ( _dim( args(2), 0 ) != Xlen )
11873  {
11874  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11875  }
11876  if ( _dim( args(2), 1 ) != Ylen )
11877  {
11878  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11879  }
11880  temp3 = args(2).matrix_value();
11881  arg3 = &temp3( 0, 0 );
11882  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11883  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11884  }
11885  ecode6 = SWIG_AsVal_int(args(3), &val6);
11886  if (!SWIG_IsOK(ecode6)) {
11887  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
11888  }
11889  arg6 = (PLINT)(val6);
11890  {
11891  if ( _n_dims( args(4) ) > 1 )
11892  {
11893  error( "argument must be a scalar or vector" ); SWIG_fail;
11894  }
11895  temp7 = args(4).matrix_value();
11896  arg7 = &temp7( 0, 0 );
11897  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11898  }
11899  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11900  _outv = octave_value();
11901  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11902  {
11903 
11904  }
11905  {
11906 
11907  }
11908  {
11909 
11910  }
11911  {
11912 
11913  }
11914 fail:
11915  return _out;
11916 }
11917 
11918 
11919 SWIG_DEFUN( plsurf3dl, _wrap_plsurf3dl, _wrap_plsurf3dl_texinfo ) {
11920  PLFLT *arg1 = (PLFLT *) 0 ;
11921  PLFLT *arg2 = (PLFLT *) 0 ;
11922  PLFLT *arg3 = (PLFLT *) 0 ;
11923  PLINT arg4 ;
11924  PLINT arg5 ;
11925  PLINT arg6 ;
11926  PLFLT *arg7 = (PLFLT *) 0 ;
11927  PLINT arg8 ;
11928  PLINT arg9 ;
11929  PLINT arg10 ;
11930  PLINT *arg11 = (PLINT *) 0 ;
11931  PLINT *arg12 = (PLINT *) 0 ;
11932  Matrix temp1 ;
11933  Matrix temp2 ;
11934  Matrix temp3 ;
11935  int val6 ;
11936  int ecode6 = 0 ;
11937  Matrix temp7 ;
11938  int val9 ;
11939  int ecode9 = 0 ;
11940  Matrix temp10 ;
11941  Matrix temp12 ;
11942  octave_value_list _out;
11943  octave_value_list *_outp=&_out;
11944  octave_value _outv;
11945 
11946  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
11947  SWIG_fail;
11948  }
11949  {
11950  if ( _n_dims( args(0) ) > 1 )
11951  {
11952  error( "argument must be a scalar or vector" ); SWIG_fail;
11953  }
11954  temp1 = args(0).matrix_value();
11955  arg1 = &temp1( 0, 0 );
11956  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11957  }
11958  {
11959  if ( _n_dims( args(1) ) > 1 )
11960  {
11961  error( "argument must be a scalar or vector" ); SWIG_fail;
11962  }
11963  temp2 = args(1).matrix_value();
11964  arg2 = &temp2( 0, 0 );
11965  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11966  }
11967  {
11968  if ( _n_dims( args(2) ) > 2 )
11969  {
11970  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11971  }
11972  if ( _dim( args(2), 0 ) != Xlen )
11973  {
11974  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11975  }
11976  if ( _dim( args(2), 1 ) != Ylen )
11977  {
11978  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11979  }
11980  temp3 = args(2).matrix_value();
11981  arg3 = &temp3( 0, 0 );
11982  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11983  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11984  }
11985  ecode6 = SWIG_AsVal_int(args(3), &val6);
11986  if (!SWIG_IsOK(ecode6)) {
11987  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
11988  }
11989  arg6 = (PLINT)(val6);
11990  {
11991  if ( _n_dims( args(4) ) > 1 )
11992  {
11993  error( "argument must be a scalar or vector" ); SWIG_fail;
11994  }
11995  temp7 = args(4).matrix_value();
11996  arg7 = &temp7( 0, 0 );
11997  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11998  }
11999  ecode9 = SWIG_AsVal_int(args(5), &val9);
12000  if (!SWIG_IsOK(ecode9)) {
12001  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12002  }
12003  arg9 = (PLINT)(val9);
12004  {
12005  if ( _n_dims( args(6) ) > 1 )
12006  {
12007  error( "argument must be a scalar or vector" ); SWIG_fail;
12008  }
12009  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12010  arg11 = new PLINT[Alen];
12011  temp10 = args(6).matrix_value();
12012  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12013  }
12014  {
12015  if ( _n_dims( args(7) ) > 1 )
12016  {
12017  error( "argument must be a scalar or vector" ); SWIG_fail;
12018  }
12019  if ( _dim( args(7), 0 ) != Alen )
12020  {
12021  error( "argument vectors must be same length" ); SWIG_fail;
12022  }
12023  temp12 = args(7).matrix_value();
12024  arg12 = new PLINT[Alen];
12025  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12026  }
12027  my_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);
12028  _outv = octave_value();
12029  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12030  {
12031 
12032  }
12033  {
12034 
12035  }
12036  {
12037 
12038  }
12039  {
12040 
12041  }
12042  {
12043  delete [] arg11;
12044  }
12045  {
12046  delete [] arg12;
12047  }
12048 fail:
12049  return _out;
12050 }
12051 
12052 
12053 SWIG_DEFUN( plshade, _wrap_plshade, _wrap_plshade_texinfo ) {
12054  PLFLT *arg1 = (PLFLT *) 0 ;
12055  PLINT arg2 ;
12056  PLINT arg3 ;
12057  PLFLT *arg4 = (PLFLT *) 0 ;
12058  PLFLT arg5 ;
12059  PLFLT arg6 ;
12060  PLFLT arg7 ;
12061  PLFLT arg8 ;
12062  PLFLT arg9 ;
12063  PLFLT arg10 ;
12064  PLINT arg11 ;
12065  PLFLT arg12 ;
12066  PLINT arg13 ;
12067  PLINT arg14 ;
12068  PLINT arg15 ;
12069  PLINT arg16 ;
12070  PLINT arg17 ;
12071  PLBOOL arg18 ;
12072  PLFLT *arg19 = (PLFLT *) 0 ;
12073  Matrix temp1 ;
12074  Matrix temp4 ;
12075  double val5 ;
12076  int ecode5 = 0 ;
12077  double val6 ;
12078  int ecode6 = 0 ;
12079  double val7 ;
12080  int ecode7 = 0 ;
12081  double val8 ;
12082  int ecode8 = 0 ;
12083  double val9 ;
12084  int ecode9 = 0 ;
12085  double val10 ;
12086  int ecode10 = 0 ;
12087  int val11 ;
12088  int ecode11 = 0 ;
12089  double val12 ;
12090  int ecode12 = 0 ;
12091  int val13 ;
12092  int ecode13 = 0 ;
12093  int val14 ;
12094  int ecode14 = 0 ;
12095  int val15 ;
12096  int ecode15 = 0 ;
12097  int val16 ;
12098  int ecode16 = 0 ;
12099  int val17 ;
12100  int ecode17 = 0 ;
12101  int val18 ;
12102  int ecode18 = 0 ;
12103  Matrix temp19 ;
12104  octave_value_list _out;
12105  octave_value_list *_outp=&_out;
12106  octave_value _outv;
12107 
12108  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12109  SWIG_fail;
12110  }
12111  {
12112  if ( _n_dims( args(0) ) > 2 )
12113  {
12114  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12115  }
12116  temp1 = args(0).matrix_value();
12117  arg1 = &temp1( 0, 0 );
12118  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12119  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12120  }
12121  {
12122  if ( _n_dims( args(1) ) > 1 )
12123  {
12124  error( "argument must be a scalar or vector" ); SWIG_fail;
12125  }
12126  Alen = (PLINT) ( _dim( args(1), 0 ) );
12127  temp4 = args(1).matrix_value();
12128  arg4 = &temp4( 0, 0 );
12129  }
12130  ecode5 = SWIG_AsVal_double(args(2), &val5);
12131  if (!SWIG_IsOK(ecode5)) {
12132  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12133  }
12134  arg5 = (PLFLT)(val5);
12135  ecode6 = SWIG_AsVal_double(args(3), &val6);
12136  if (!SWIG_IsOK(ecode6)) {
12137  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12138  }
12139  arg6 = (PLFLT)(val6);
12140  ecode7 = SWIG_AsVal_double(args(4), &val7);
12141  if (!SWIG_IsOK(ecode7)) {
12142  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12143  }
12144  arg7 = (PLFLT)(val7);
12145  ecode8 = SWIG_AsVal_double(args(5), &val8);
12146  if (!SWIG_IsOK(ecode8)) {
12147  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12148  }
12149  arg8 = (PLFLT)(val8);
12150  ecode9 = SWIG_AsVal_double(args(6), &val9);
12151  if (!SWIG_IsOK(ecode9)) {
12152  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12153  }
12154  arg9 = (PLFLT)(val9);
12155  ecode10 = SWIG_AsVal_double(args(7), &val10);
12156  if (!SWIG_IsOK(ecode10)) {
12157  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12158  }
12159  arg10 = (PLFLT)(val10);
12160  ecode11 = SWIG_AsVal_int(args(8), &val11);
12161  if (!SWIG_IsOK(ecode11)) {
12162  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12163  }
12164  arg11 = (PLINT)(val11);
12165  ecode12 = SWIG_AsVal_double(args(9), &val12);
12166  if (!SWIG_IsOK(ecode12)) {
12167  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12168  }
12169  arg12 = (PLFLT)(val12);
12170  ecode13 = SWIG_AsVal_int(args(10), &val13);
12171  if (!SWIG_IsOK(ecode13)) {
12172  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
12173  }
12174  arg13 = (PLINT)(val13);
12175  ecode14 = SWIG_AsVal_int(args(11), &val14);
12176  if (!SWIG_IsOK(ecode14)) {
12177  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12178  }
12179  arg14 = (PLINT)(val14);
12180  ecode15 = SWIG_AsVal_int(args(12), &val15);
12181  if (!SWIG_IsOK(ecode15)) {
12182  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
12183  }
12184  arg15 = (PLINT)(val15);
12185  ecode16 = SWIG_AsVal_int(args(13), &val16);
12186  if (!SWIG_IsOK(ecode16)) {
12187  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12188  }
12189  arg16 = (PLINT)(val16);
12190  ecode17 = SWIG_AsVal_int(args(14), &val17);
12191  if (!SWIG_IsOK(ecode17)) {
12192  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
12193  }
12194  arg17 = (PLINT)(val17);
12195  ecode18 = SWIG_AsVal_int(args(15), &val18);
12196  if (!SWIG_IsOK(ecode18)) {
12197  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
12198  }
12199  arg18 = (PLBOOL)(val18);
12200  {
12201  if ( _n_dims( args(16) ) > 1 )
12202  {
12203  error( "argument must be a scalar or vector" ); SWIG_fail;
12204  }
12205  if ( _dim( args(16), 0 ) != 6 )
12206  {
12207  error( "argument vectors must have length of 6" ); SWIG_fail;
12208  }
12209  temp19 = args(16).matrix_value();
12210  arg19 = &temp19( 0, 0 );
12211  }
12212  my_plshade((double const *)arg1,arg2,arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
12213  _outv = octave_value();
12214  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12215  {
12216 
12217  }
12218  {
12219 
12220  }
12221  {
12222 
12223  }
12224 fail:
12225  return _out;
12226 }
12227 
12228 
12229 SWIG_DEFUN( plshade1, _wrap_plshade1, _wrap_plshade1_texinfo ) {
12230  PLFLT *arg1 = (PLFLT *) 0 ;
12231  PLINT arg2 ;
12232  PLINT arg3 ;
12233  char *arg4 = (char *) 0 ;
12234  PLFLT arg5 ;
12235  PLFLT arg6 ;
12236  PLFLT arg7 ;
12237  PLFLT arg8 ;
12238  PLFLT arg9 ;
12239  PLFLT arg10 ;
12240  PLINT arg11 ;
12241  PLFLT arg12 ;
12242  PLINT arg13 ;
12243  PLINT arg14 ;
12244  PLINT arg15 ;
12245  PLINT arg16 ;
12246  PLINT arg17 ;
12247  PLBOOL arg18 ;
12248  PLFLT *arg19 = (PLFLT *) 0 ;
12249  PLFLT *arg20 = (PLFLT *) 0 ;
12250  Matrix temp1 ;
12251  int res4 ;
12252  char *buf4 = 0 ;
12253  int alloc4 = 0 ;
12254  double val5 ;
12255  int ecode5 = 0 ;
12256  double val6 ;
12257  int ecode6 = 0 ;
12258  double val7 ;
12259  int ecode7 = 0 ;
12260  double val8 ;
12261  int ecode8 = 0 ;
12262  double val9 ;
12263  int ecode9 = 0 ;
12264  double val10 ;
12265  int ecode10 = 0 ;
12266  int val11 ;
12267  int ecode11 = 0 ;
12268  double val12 ;
12269  int ecode12 = 0 ;
12270  int val13 ;
12271  int ecode13 = 0 ;
12272  int val14 ;
12273  int ecode14 = 0 ;
12274  int val15 ;
12275  int ecode15 = 0 ;
12276  int val16 ;
12277  int ecode16 = 0 ;
12278  int val17 ;
12279  int ecode17 = 0 ;
12280  int val18 ;
12281  int ecode18 = 0 ;
12282  Matrix temp19 ;
12283  Matrix temp20 ;
12284  octave_value_list _out;
12285  octave_value_list *_outp=&_out;
12286  octave_value _outv;
12287 
12288  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
12289  SWIG_fail;
12290  }
12291  {
12292  if ( _n_dims( args(0) ) > 2 )
12293  {
12294  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12295  }
12296  temp1 = args(0).matrix_value();
12297  arg1 = &temp1( 0, 0 );
12298  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12299  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12300  }
12301  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
12302  if (!SWIG_IsOK(res4)) {
12303  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
12304  }
12305  arg4 = (char *)(buf4);
12306  ecode5 = SWIG_AsVal_double(args(2), &val5);
12307  if (!SWIG_IsOK(ecode5)) {
12308  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
12309  }
12310  arg5 = (PLFLT)(val5);
12311  ecode6 = SWIG_AsVal_double(args(3), &val6);
12312  if (!SWIG_IsOK(ecode6)) {
12313  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
12314  }
12315  arg6 = (PLFLT)(val6);
12316  ecode7 = SWIG_AsVal_double(args(4), &val7);
12317  if (!SWIG_IsOK(ecode7)) {
12318  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
12319  }
12320  arg7 = (PLFLT)(val7);
12321  ecode8 = SWIG_AsVal_double(args(5), &val8);
12322  if (!SWIG_IsOK(ecode8)) {
12323  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
12324  }
12325  arg8 = (PLFLT)(val8);
12326  ecode9 = SWIG_AsVal_double(args(6), &val9);
12327  if (!SWIG_IsOK(ecode9)) {
12328  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
12329  }
12330  arg9 = (PLFLT)(val9);
12331  ecode10 = SWIG_AsVal_double(args(7), &val10);
12332  if (!SWIG_IsOK(ecode10)) {
12333  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
12334  }
12335  arg10 = (PLFLT)(val10);
12336  ecode11 = SWIG_AsVal_int(args(8), &val11);
12337  if (!SWIG_IsOK(ecode11)) {
12338  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
12339  }
12340  arg11 = (PLINT)(val11);
12341  ecode12 = SWIG_AsVal_double(args(9), &val12);
12342  if (!SWIG_IsOK(ecode12)) {
12343  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
12344  }
12345  arg12 = (PLFLT)(val12);
12346  ecode13 = SWIG_AsVal_int(args(10), &val13);
12347  if (!SWIG_IsOK(ecode13)) {
12348  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
12349  }
12350  arg13 = (PLINT)(val13);
12351  ecode14 = SWIG_AsVal_int(args(11), &val14);
12352  if (!SWIG_IsOK(ecode14)) {
12353  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
12354  }
12355  arg14 = (PLINT)(val14);
12356  ecode15 = SWIG_AsVal_int(args(12), &val15);
12357  if (!SWIG_IsOK(ecode15)) {
12358  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
12359  }
12360  arg15 = (PLINT)(val15);
12361  ecode16 = SWIG_AsVal_int(args(13), &val16);
12362  if (!SWIG_IsOK(ecode16)) {
12363  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
12364  }
12365  arg16 = (PLINT)(val16);
12366  ecode17 = SWIG_AsVal_int(args(14), &val17);
12367  if (!SWIG_IsOK(ecode17)) {
12368  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
12369  }
12370  arg17 = (PLINT)(val17);
12371  ecode18 = SWIG_AsVal_int(args(15), &val18);
12372  if (!SWIG_IsOK(ecode18)) {
12373  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
12374  }
12375  arg18 = (PLBOOL)(val18);
12376  {
12377  if ( _n_dims( args(16) ) > 1 )
12378  {
12379  error( "argument must be a scalar or vector" ); SWIG_fail;
12380  }
12381  if ( _dim( args(16), 0 ) != Xlen )
12382  {
12383  error( "argument vectors must be same length" ); SWIG_fail;
12384  }
12385  temp19 = args(16).matrix_value();
12386  arg19 = &temp19( 0, 0 );
12387  }
12388  {
12389  if ( _n_dims( args(17) ) > 1 )
12390  {
12391  error( "argument must be a scalar or vector" ); SWIG_fail;
12392  }
12393  if ( _dim( args(17), 0 ) != Ylen )
12394  {
12395  error( "argument vectors must be same length" ); SWIG_fail;
12396  }
12397  temp20 = args(17).matrix_value();
12398  arg20 = &temp20( 0, 0 );
12399  }
12400  my_plshade1((double const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(double const *)arg19,(double const *)arg20);
12401  _outv = octave_value();
12402  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12403  {
12404 
12405  }
12406  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12407  {
12408 
12409  }
12410  {
12411 
12412  }
12413 fail:
12414  return _out;
12415 }
12416 
12417 
12418 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
12419  PLFLT *arg1 = (PLFLT *) 0 ;
12420  PLINT arg2 ;
12421  PLINT arg3 ;
12422  char *arg4 = (char *) 0 ;
12423  PLFLT arg5 ;
12424  PLFLT arg6 ;
12425  PLFLT arg7 ;
12426  PLFLT arg8 ;
12427  PLFLT arg9 ;
12428  PLFLT arg10 ;
12429  PLINT arg11 ;
12430  PLFLT arg12 ;
12431  PLINT arg13 ;
12432  PLINT arg14 ;
12433  PLINT arg15 ;
12434  PLINT arg16 ;
12435  PLINT arg17 ;
12436  PLBOOL arg18 ;
12437  PLFLT *arg19 = (PLFLT *) 0 ;
12438  PLFLT *arg20 = (PLFLT *) 0 ;
12439  Matrix temp1 ;
12440  int res4 ;
12441  char *buf4 = 0 ;
12442  int alloc4 = 0 ;
12443  double val5 ;
12444  int ecode5 = 0 ;
12445  double val6 ;
12446  int ecode6 = 0 ;
12447  double val7 ;
12448  int ecode7 = 0 ;
12449  double val8 ;
12450  int ecode8 = 0 ;
12451  double val9 ;
12452  int ecode9 = 0 ;
12453  double val10 ;
12454  int ecode10 = 0 ;
12455  int val11 ;
12456  int ecode11 = 0 ;
12457  double val12 ;
12458  int ecode12 = 0 ;
12459  int val13 ;
12460  int ecode13 = 0 ;
12461  int val14 ;
12462  int ecode14 = 0 ;
12463  int val15 ;
12464  int ecode15 = 0 ;
12465  int val16 ;
12466  int ecode16 = 0 ;
12467  int val17 ;
12468  int ecode17 = 0 ;
12469  int val18 ;
12470  int ecode18 = 0 ;
12471  Matrix temp19 ;
12472  Matrix temp20 ;
12473  octave_value_list _out;
12474  octave_value_list *_outp=&_out;
12475  octave_value _outv;
12476 
12477  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
12478  SWIG_fail;
12479  }
12480  {
12481  if ( _n_dims( args(0) ) > 2 )
12482  {
12483  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12484  }
12485  temp1 = args(0).matrix_value();
12486  arg1 = &temp1( 0, 0 );
12487  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12488  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12489  }
12490  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
12491  if (!SWIG_IsOK(res4)) {
12492  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
12493  }
12494  arg4 = (char *)(buf4);
12495  ecode5 = SWIG_AsVal_double(args(2), &val5);
12496  if (!SWIG_IsOK(ecode5)) {
12497  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
12498  }
12499  arg5 = (PLFLT)(val5);
12500  ecode6 = SWIG_AsVal_double(args(3), &val6);
12501  if (!SWIG_IsOK(ecode6)) {
12502  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
12503  }
12504  arg6 = (PLFLT)(val6);
12505  ecode7 = SWIG_AsVal_double(args(4), &val7);
12506  if (!SWIG_IsOK(ecode7)) {
12507  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
12508  }
12509  arg7 = (PLFLT)(val7);
12510  ecode8 = SWIG_AsVal_double(args(5), &val8);
12511  if (!SWIG_IsOK(ecode8)) {
12512  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
12513  }
12514  arg8 = (PLFLT)(val8);
12515  ecode9 = SWIG_AsVal_double(args(6), &val9);
12516  if (!SWIG_IsOK(ecode9)) {
12517  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
12518  }
12519  arg9 = (PLFLT)(val9);
12520  ecode10 = SWIG_AsVal_double(args(7), &val10);
12521  if (!SWIG_IsOK(ecode10)) {
12522  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
12523  }
12524  arg10 = (PLFLT)(val10);
12525  ecode11 = SWIG_AsVal_int(args(8), &val11);
12526  if (!SWIG_IsOK(ecode11)) {
12527  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
12528  }
12529  arg11 = (PLINT)(val11);
12530  ecode12 = SWIG_AsVal_double(args(9), &val12);
12531  if (!SWIG_IsOK(ecode12)) {
12532  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
12533  }
12534  arg12 = (PLFLT)(val12);
12535  ecode13 = SWIG_AsVal_int(args(10), &val13);
12536  if (!SWIG_IsOK(ecode13)) {
12537  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
12538  }
12539  arg13 = (PLINT)(val13);
12540  ecode14 = SWIG_AsVal_int(args(11), &val14);
12541  if (!SWIG_IsOK(ecode14)) {
12542  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
12543  }
12544  arg14 = (PLINT)(val14);
12545  ecode15 = SWIG_AsVal_int(args(12), &val15);
12546  if (!SWIG_IsOK(ecode15)) {
12547  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
12548  }
12549  arg15 = (PLINT)(val15);
12550  ecode16 = SWIG_AsVal_int(args(13), &val16);
12551  if (!SWIG_IsOK(ecode16)) {
12552  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
12553  }
12554  arg16 = (PLINT)(val16);
12555  ecode17 = SWIG_AsVal_int(args(14), &val17);
12556  if (!SWIG_IsOK(ecode17)) {
12557  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
12558  }
12559  arg17 = (PLINT)(val17);
12560  ecode18 = SWIG_AsVal_int(args(15), &val18);
12561  if (!SWIG_IsOK(ecode18)) {
12562  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
12563  }
12564  arg18 = (PLBOOL)(val18);
12565  {
12566  if ( _n_dims( args(16) ) > 2 )
12567  {
12568  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12569  }
12570  temp19 = args(16).matrix_value();
12571  arg19 = &temp19( 0, 0 );
12572  Xlen = (PLINT) ( _dim( args(16), 0 ) );
12573  Ylen = (PLINT) ( _dim( args(16), 1 ) );
12574  }
12575  {
12576  if ( _n_dims( args(17) ) > 2 )
12577  {
12578  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12579  }
12580  temp20 = args(17).matrix_value();
12581  arg20 = &temp20( 0, 0 );
12582  Xlen = (PLINT) ( _dim( args(17), 0 ) );
12583  Ylen = (PLINT) ( _dim( args(17), 1 ) );
12584  }
12585  my_plshade2((double const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,(double const *)arg19,(double const *)arg20);
12586  _outv = octave_value();
12587  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12588  {
12589 
12590  }
12591  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12592  {
12593 
12594  }
12595  {
12596 
12597  }
12598 fail:
12599  return _out;
12600 }
12601 
12602 
12603 SWIG_DEFUN( plshades, _wrap_plshades, _wrap_plshades_texinfo ) {
12604  PLFLT *arg1 = (PLFLT *) 0 ;
12605  PLINT arg2 ;
12606  PLINT arg3 ;
12607  PLFLT arg4 ;
12608  PLFLT arg5 ;
12609  PLFLT arg6 ;
12610  PLFLT arg7 ;
12611  PLFLT *arg8 = (PLFLT *) 0 ;
12612  PLINT arg9 ;
12613  PLINT arg10 ;
12614  PLINT arg11 ;
12615  PLINT arg12 ;
12616  PLBOOL arg13 ;
12617  Matrix temp1 ;
12618  double val4 ;
12619  int ecode4 = 0 ;
12620  double val5 ;
12621  int ecode5 = 0 ;
12622  double val6 ;
12623  int ecode6 = 0 ;
12624  double val7 ;
12625  int ecode7 = 0 ;
12626  Matrix temp8 ;
12627  int val10 ;
12628  int ecode10 = 0 ;
12629  int val11 ;
12630  int ecode11 = 0 ;
12631  int val12 ;
12632  int ecode12 = 0 ;
12633  int val13 ;
12634  int ecode13 = 0 ;
12635  octave_value_list _out;
12636  octave_value_list *_outp=&_out;
12637  octave_value _outv;
12638 
12639  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
12640  SWIG_fail;
12641  }
12642  {
12643  if ( _n_dims( args(0) ) > 2 )
12644  {
12645  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12646  }
12647  temp1 = args(0).matrix_value();
12648  arg1 = &temp1( 0, 0 );
12649  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12650  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12651  }
12652  ecode4 = SWIG_AsVal_double(args(1), &val4);
12653  if (!SWIG_IsOK(ecode4)) {
12654  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
12655  }
12656  arg4 = (PLFLT)(val4);
12657  ecode5 = SWIG_AsVal_double(args(2), &val5);
12658  if (!SWIG_IsOK(ecode5)) {
12659  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12660  }
12661  arg5 = (PLFLT)(val5);
12662  ecode6 = SWIG_AsVal_double(args(3), &val6);
12663  if (!SWIG_IsOK(ecode6)) {
12664  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12665  }
12666  arg6 = (PLFLT)(val6);
12667  ecode7 = SWIG_AsVal_double(args(4), &val7);
12668  if (!SWIG_IsOK(ecode7)) {
12669  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12670  }
12671  arg7 = (PLFLT)(val7);
12672  {
12673  if ( _n_dims( args(5) ) > 1 )
12674  {
12675  error( "argument must be a scalar or vector" ); SWIG_fail;
12676  }
12677  temp8 = args(5).matrix_value();
12678  arg8 = &temp8( 0, 0 );
12679  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12680  }
12681  ecode10 = SWIG_AsVal_int(args(6), &val10);
12682  if (!SWIG_IsOK(ecode10)) {
12683  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
12684  }
12685  arg10 = (PLINT)(val10);
12686  ecode11 = SWIG_AsVal_int(args(7), &val11);
12687  if (!SWIG_IsOK(ecode11)) {
12688  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
12689  }
12690  arg11 = (PLINT)(val11);
12691  ecode12 = SWIG_AsVal_int(args(8), &val12);
12692  if (!SWIG_IsOK(ecode12)) {
12693  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12694  }
12695  arg12 = (PLINT)(val12);
12696  ecode13 = SWIG_AsVal_int(args(9), &val13);
12697  if (!SWIG_IsOK(ecode13)) {
12698  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
12699  }
12700  arg13 = (PLBOOL)(val13);
12701  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
12702  _outv = octave_value();
12703  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12704  {
12705 
12706  }
12707  {
12708 
12709  }
12710 fail:
12711  return _out;
12712 }
12713 
12714 
12715 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
12716  PLFLT *arg1 = (PLFLT *) 0 ;
12717  PLINT arg2 ;
12718  PLINT arg3 ;
12719  PLFLT arg4 ;
12720  PLFLT arg5 ;
12721  PLFLT arg6 ;
12722  PLFLT arg7 ;
12723  PLFLT *arg8 = (PLFLT *) 0 ;
12724  PLINT arg9 ;
12725  PLINT arg10 ;
12726  PLINT arg11 ;
12727  PLINT arg12 ;
12728  PLBOOL arg13 ;
12729  PLFLT *arg14 = (PLFLT *) 0 ;
12730  Matrix temp1 ;
12731  double val4 ;
12732  int ecode4 = 0 ;
12733  double val5 ;
12734  int ecode5 = 0 ;
12735  double val6 ;
12736  int ecode6 = 0 ;
12737  double val7 ;
12738  int ecode7 = 0 ;
12739  Matrix temp8 ;
12740  int val10 ;
12741  int ecode10 = 0 ;
12742  int val11 ;
12743  int ecode11 = 0 ;
12744  int val12 ;
12745  int ecode12 = 0 ;
12746  int val13 ;
12747  int ecode13 = 0 ;
12748  Matrix temp14 ;
12749  octave_value_list _out;
12750  octave_value_list *_outp=&_out;
12751  octave_value _outv;
12752 
12753  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
12754  SWIG_fail;
12755  }
12756  {
12757  if ( _n_dims( args(0) ) > 2 )
12758  {
12759  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12760  }
12761  temp1 = args(0).matrix_value();
12762  arg1 = &temp1( 0, 0 );
12763  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12764  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12765  }
12766  ecode4 = SWIG_AsVal_double(args(1), &val4);
12767  if (!SWIG_IsOK(ecode4)) {
12768  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
12769  }
12770  arg4 = (PLFLT)(val4);
12771  ecode5 = SWIG_AsVal_double(args(2), &val5);
12772  if (!SWIG_IsOK(ecode5)) {
12773  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
12774  }
12775  arg5 = (PLFLT)(val5);
12776  ecode6 = SWIG_AsVal_double(args(3), &val6);
12777  if (!SWIG_IsOK(ecode6)) {
12778  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
12779  }
12780  arg6 = (PLFLT)(val6);
12781  ecode7 = SWIG_AsVal_double(args(4), &val7);
12782  if (!SWIG_IsOK(ecode7)) {
12783  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
12784  }
12785  arg7 = (PLFLT)(val7);
12786  {
12787  if ( _n_dims( args(5) ) > 1 )
12788  {
12789  error( "argument must be a scalar or vector" ); SWIG_fail;
12790  }
12791  temp8 = args(5).matrix_value();
12792  arg8 = &temp8( 0, 0 );
12793  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12794  }
12795  ecode10 = SWIG_AsVal_int(args(6), &val10);
12796  if (!SWIG_IsOK(ecode10)) {
12797  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
12798  }
12799  arg10 = (PLINT)(val10);
12800  ecode11 = SWIG_AsVal_int(args(7), &val11);
12801  if (!SWIG_IsOK(ecode11)) {
12802  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
12803  }
12804  arg11 = (PLINT)(val11);
12805  ecode12 = SWIG_AsVal_int(args(8), &val12);
12806  if (!SWIG_IsOK(ecode12)) {
12807  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
12808  }
12809  arg12 = (PLINT)(val12);
12810  ecode13 = SWIG_AsVal_int(args(9), &val13);
12811  if (!SWIG_IsOK(ecode13)) {
12812  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
12813  }
12814  arg13 = (PLBOOL)(val13);
12815  {
12816  if ( _n_dims( args(10) ) > 1 )
12817  {
12818  error( "argument must be a scalar or vector" ); SWIG_fail;
12819  }
12820  if ( _dim( args(10), 0 ) != 6 )
12821  {
12822  error( "argument vectors must have length of 6" ); SWIG_fail;
12823  }
12824  temp14 = args(10).matrix_value();
12825  arg14 = &temp14( 0, 0 );
12826  }
12827  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12828  _outv = octave_value();
12829  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12830  {
12831 
12832  }
12833  {
12834 
12835  }
12836  {
12837 
12838  }
12839 fail:
12840  return _out;
12841 }
12842 
12843 
12844 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
12845  PLFLT *arg1 = (PLFLT *) 0 ;
12846  PLINT arg2 ;
12847  PLINT arg3 ;
12848  PLFLT arg4 ;
12849  PLFLT arg5 ;
12850  PLFLT arg6 ;
12851  PLFLT arg7 ;
12852  PLFLT *arg8 = (PLFLT *) 0 ;
12853  PLINT arg9 ;
12854  PLINT arg10 ;
12855  PLINT arg11 ;
12856  PLINT arg12 ;
12857  PLBOOL arg13 ;
12858  PLFLT *arg14 = (PLFLT *) 0 ;
12859  PLFLT *arg15 = (PLFLT *) 0 ;
12860  Matrix temp1 ;
12861  double val4 ;
12862  int ecode4 = 0 ;
12863  double val5 ;
12864  int ecode5 = 0 ;
12865  double val6 ;
12866  int ecode6 = 0 ;
12867  double val7 ;
12868  int ecode7 = 0 ;
12869  Matrix temp8 ;
12870  int val10 ;
12871  int ecode10 = 0 ;
12872  int val11 ;
12873  int ecode11 = 0 ;
12874  int val12 ;
12875  int ecode12 = 0 ;
12876  int val13 ;
12877  int ecode13 = 0 ;
12878  Matrix temp14 ;
12879  Matrix temp15 ;
12880  octave_value_list _out;
12881  octave_value_list *_outp=&_out;
12882  octave_value _outv;
12883 
12884  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
12885  SWIG_fail;
12886  }
12887  {
12888  if ( _n_dims( args(0) ) > 2 )
12889  {
12890  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12891  }
12892  temp1 = args(0).matrix_value();
12893  arg1 = &temp1( 0, 0 );
12894  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12895  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12896  }
12897  ecode4 = SWIG_AsVal_double(args(1), &val4);
12898  if (!SWIG_IsOK(ecode4)) {
12899  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
12900  }
12901  arg4 = (PLFLT)(val4);
12902  ecode5 = SWIG_AsVal_double(args(2), &val5);
12903  if (!SWIG_IsOK(ecode5)) {
12904  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
12905  }
12906  arg5 = (PLFLT)(val5);
12907  ecode6 = SWIG_AsVal_double(args(3), &val6);
12908  if (!SWIG_IsOK(ecode6)) {
12909  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
12910  }
12911  arg6 = (PLFLT)(val6);
12912  ecode7 = SWIG_AsVal_double(args(4), &val7);
12913  if (!SWIG_IsOK(ecode7)) {
12914  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
12915  }
12916  arg7 = (PLFLT)(val7);
12917  {
12918  if ( _n_dims( args(5) ) > 1 )
12919  {
12920  error( "argument must be a scalar or vector" ); SWIG_fail;
12921  }
12922  temp8 = args(5).matrix_value();
12923  arg8 = &temp8( 0, 0 );
12924  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12925  }
12926  ecode10 = SWIG_AsVal_int(args(6), &val10);
12927  if (!SWIG_IsOK(ecode10)) {
12928  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
12929  }
12930  arg10 = (PLINT)(val10);
12931  ecode11 = SWIG_AsVal_int(args(7), &val11);
12932  if (!SWIG_IsOK(ecode11)) {
12933  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
12934  }
12935  arg11 = (PLINT)(val11);
12936  ecode12 = SWIG_AsVal_int(args(8), &val12);
12937  if (!SWIG_IsOK(ecode12)) {
12938  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
12939  }
12940  arg12 = (PLINT)(val12);
12941  ecode13 = SWIG_AsVal_int(args(9), &val13);
12942  if (!SWIG_IsOK(ecode13)) {
12943  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
12944  }
12945  arg13 = (PLBOOL)(val13);
12946  {
12947  if ( _n_dims( args(10) ) > 1 )
12948  {
12949  error( "argument must be a scalar or vector" ); SWIG_fail;
12950  }
12951  if ( _dim( args(10), 0 ) != Xlen )
12952  {
12953  error( "argument vectors must be same length" ); SWIG_fail;
12954  }
12955  temp14 = args(10).matrix_value();
12956  arg14 = &temp14( 0, 0 );
12957  }
12958  {
12959  if ( _n_dims( args(11) ) > 1 )
12960  {
12961  error( "argument must be a scalar or vector" ); SWIG_fail;
12962  }
12963  if ( _dim( args(11), 0 ) != Ylen )
12964  {
12965  error( "argument vectors must be same length" ); SWIG_fail;
12966  }
12967  temp15 = args(11).matrix_value();
12968  arg15 = &temp15( 0, 0 );
12969  }
12970  my_plshades1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,(double const *)arg14,(double const *)arg15);
12971  _outv = octave_value();
12972  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12973  {
12974 
12975  }
12976  {
12977 
12978  }
12979  {
12980 
12981  }
12982  {
12983 
12984  }
12985 fail:
12986  return _out;
12987 }
12988 
12989 
12990 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
12991  PLFLT *arg1 = (PLFLT *) 0 ;
12992  PLINT arg2 ;
12993  PLINT arg3 ;
12994  PLFLT arg4 ;
12995  PLFLT arg5 ;
12996  PLFLT arg6 ;
12997  PLFLT arg7 ;
12998  PLFLT *arg8 = (PLFLT *) 0 ;
12999  PLINT arg9 ;
13000  PLINT arg10 ;
13001  PLINT arg11 ;
13002  PLINT arg12 ;
13003  PLBOOL arg13 ;
13004  PLFLT *arg14 = (PLFLT *) 0 ;
13005  PLFLT *arg15 = (PLFLT *) 0 ;
13006  Matrix temp1 ;
13007  double val4 ;
13008  int ecode4 = 0 ;
13009  double val5 ;
13010  int ecode5 = 0 ;
13011  double val6 ;
13012  int ecode6 = 0 ;
13013  double val7 ;
13014  int ecode7 = 0 ;
13015  Matrix temp8 ;
13016  int val10 ;
13017  int ecode10 = 0 ;
13018  int val11 ;
13019  int ecode11 = 0 ;
13020  int val12 ;
13021  int ecode12 = 0 ;
13022  int val13 ;
13023  int ecode13 = 0 ;
13024  Matrix temp14 ;
13025  Matrix temp15 ;
13026  octave_value_list _out;
13027  octave_value_list *_outp=&_out;
13028  octave_value _outv;
13029 
13030  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13031  SWIG_fail;
13032  }
13033  {
13034  if ( _n_dims( args(0) ) > 2 )
13035  {
13036  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13037  }
13038  temp1 = args(0).matrix_value();
13039  arg1 = &temp1( 0, 0 );
13040  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13041  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13042  }
13043  ecode4 = SWIG_AsVal_double(args(1), &val4);
13044  if (!SWIG_IsOK(ecode4)) {
13045  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13046  }
13047  arg4 = (PLFLT)(val4);
13048  ecode5 = SWIG_AsVal_double(args(2), &val5);
13049  if (!SWIG_IsOK(ecode5)) {
13050  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13051  }
13052  arg5 = (PLFLT)(val5);
13053  ecode6 = SWIG_AsVal_double(args(3), &val6);
13054  if (!SWIG_IsOK(ecode6)) {
13055  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13056  }
13057  arg6 = (PLFLT)(val6);
13058  ecode7 = SWIG_AsVal_double(args(4), &val7);
13059  if (!SWIG_IsOK(ecode7)) {
13060  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13061  }
13062  arg7 = (PLFLT)(val7);
13063  {
13064  if ( _n_dims( args(5) ) > 1 )
13065  {
13066  error( "argument must be a scalar or vector" ); SWIG_fail;
13067  }
13068  temp8 = args(5).matrix_value();
13069  arg8 = &temp8( 0, 0 );
13070  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13071  }
13072  ecode10 = SWIG_AsVal_int(args(6), &val10);
13073  if (!SWIG_IsOK(ecode10)) {
13074  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13075  }
13076  arg10 = (PLINT)(val10);
13077  ecode11 = SWIG_AsVal_int(args(7), &val11);
13078  if (!SWIG_IsOK(ecode11)) {
13079  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13080  }
13081  arg11 = (PLINT)(val11);
13082  ecode12 = SWIG_AsVal_int(args(8), &val12);
13083  if (!SWIG_IsOK(ecode12)) {
13084  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13085  }
13086  arg12 = (PLINT)(val12);
13087  ecode13 = SWIG_AsVal_int(args(9), &val13);
13088  if (!SWIG_IsOK(ecode13)) {
13089  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13090  }
13091  arg13 = (PLBOOL)(val13);
13092  {
13093  if ( _n_dims( args(10) ) > 2 )
13094  {
13095  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13096  }
13097  temp14 = args(10).matrix_value();
13098  arg14 = &temp14( 0, 0 );
13099  Xlen = (PLINT) ( _dim( args(10), 0 ) );
13100  Ylen = (PLINT) ( _dim( args(10), 1 ) );
13101  }
13102  {
13103  if ( _n_dims( args(11) ) > 2 )
13104  {
13105  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13106  }
13107  temp15 = args(11).matrix_value();
13108  arg15 = &temp15( 0, 0 );
13109  Xlen = (PLINT) ( _dim( args(11), 0 ) );
13110  Ylen = (PLINT) ( _dim( args(11), 1 ) );
13111  }
13112  my_plshades2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,(double const *)arg14,(double const *)arg15);
13113  _outv = octave_value();
13114  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13115  {
13116 
13117  }
13118  {
13119 
13120  }
13121  {
13122 
13123  }
13124  {
13125 
13126  }
13127 fail:
13128  return _out;
13129 }
13130 
13131 
13132 SWIG_DEFUN( plvect, _wrap_plvect, _wrap_plvect_texinfo ) {
13133  PLFLT *arg1 = (PLFLT *) 0 ;
13134  PLFLT *arg2 = (PLFLT *) 0 ;
13135  PLINT arg3 ;
13136  PLINT arg4 ;
13137  PLFLT arg5 ;
13138  PLFLT *arg6 = (PLFLT *) 0 ;
13139  Matrix temp1 ;
13140  Matrix temp2 ;
13141  double val5 ;
13142  int ecode5 = 0 ;
13143  Matrix temp6 ;
13144  octave_value_list _out;
13145  octave_value_list *_outp=&_out;
13146  octave_value _outv;
13147 
13148  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
13149  SWIG_fail;
13150  }
13151  {
13152  if ( _n_dims( args(0) ) > 2 )
13153  {
13154  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13155  }
13156  temp1 = args(0).matrix_value();
13157  arg1 = &temp1( 0, 0 );
13158  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13159  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13160  }
13161  {
13162  if ( _n_dims( args(1) ) > 2 )
13163  {
13164  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13165  }
13166  if ( _dim( args(1), 0 ) != Xlen )
13167  {
13168  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13169  }
13170  if ( _dim( args(1), 1 ) != Ylen )
13171  {
13172  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13173  }
13174  temp2 = args(1).matrix_value();
13175  arg2 = &temp2( 0, 0 );
13176  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13177  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13178  }
13179  ecode5 = SWIG_AsVal_double(args(2), &val5);
13180  if (!SWIG_IsOK(ecode5)) {
13181  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13182  }
13183  arg5 = (PLFLT)(val5);
13184  {
13185  if ( _n_dims( args(3) ) > 1 )
13186  {
13187  error( "argument must be a scalar or vector" ); SWIG_fail;
13188  }
13189  if ( _dim( args(3), 0 ) != 6 )
13190  {
13191  error( "argument vectors must have length of 6" ); SWIG_fail;
13192  }
13193  temp6 = args(3).matrix_value();
13194  arg6 = &temp6( 0, 0 );
13195  }
13196  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
13197  _outv = octave_value();
13198  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13199  {
13200 
13201  }
13202  {
13203 
13204  }
13205  {
13206 
13207  }
13208 fail:
13209  return _out;
13210 }
13211 
13212 
13213 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
13214  PLFLT *arg1 = (PLFLT *) 0 ;
13215  PLFLT *arg2 = (PLFLT *) 0 ;
13216  PLINT arg3 ;
13217  PLINT arg4 ;
13218  PLFLT arg5 ;
13219  PLFLT *arg6 = (PLFLT *) 0 ;
13220  PLFLT *arg7 = (PLFLT *) 0 ;
13221  Matrix temp1 ;
13222  Matrix temp2 ;
13223  double val5 ;
13224  int ecode5 = 0 ;
13225  Matrix temp6 ;
13226  Matrix temp7 ;
13227  octave_value_list _out;
13228  octave_value_list *_outp=&_out;
13229  octave_value _outv;
13230 
13231  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
13232  SWIG_fail;
13233  }
13234  {
13235  if ( _n_dims( args(0) ) > 2 )
13236  {
13237  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13238  }
13239  temp1 = args(0).matrix_value();
13240  arg1 = &temp1( 0, 0 );
13241  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13242  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13243  }
13244  {
13245  if ( _n_dims( args(1) ) > 2 )
13246  {
13247  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13248  }
13249  if ( _dim( args(1), 0 ) != Xlen )
13250  {
13251  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13252  }
13253  if ( _dim( args(1), 1 ) != Ylen )
13254  {
13255  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13256  }
13257  temp2 = args(1).matrix_value();
13258  arg2 = &temp2( 0, 0 );
13259  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13260  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13261  }
13262  ecode5 = SWIG_AsVal_double(args(2), &val5);
13263  if (!SWIG_IsOK(ecode5)) {
13264  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
13265  }
13266  arg5 = (PLFLT)(val5);
13267  {
13268  if ( _n_dims( args(3) ) > 1 )
13269  {
13270  error( "argument must be a scalar or vector" ); SWIG_fail;
13271  }
13272  if ( _dim( args(3), 0 ) != Xlen )
13273  {
13274  error( "argument vectors must be same length" ); SWIG_fail;
13275  }
13276  temp6 = args(3).matrix_value();
13277  arg6 = &temp6( 0, 0 );
13278  }
13279  {
13280  if ( _n_dims( args(4) ) > 1 )
13281  {
13282  error( "argument must be a scalar or vector" ); SWIG_fail;
13283  }
13284  if ( _dim( args(4), 0 ) != Ylen )
13285  {
13286  error( "argument vectors must be same length" ); SWIG_fail;
13287  }
13288  temp7 = args(4).matrix_value();
13289  arg7 = &temp7( 0, 0 );
13290  }
13291  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
13292  _outv = octave_value();
13293  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13294  {
13295 
13296  }
13297  {
13298 
13299  }
13300  {
13301 
13302  }
13303  {
13304 
13305  }
13306 fail:
13307  return _out;
13308 }
13309 
13310 
13311 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
13312  PLFLT *arg1 = (PLFLT *) 0 ;
13313  PLFLT *arg2 = (PLFLT *) 0 ;
13314  PLINT arg3 ;
13315  PLINT arg4 ;
13316  PLFLT arg5 ;
13317  PLFLT *arg6 = (PLFLT *) 0 ;
13318  PLFLT *arg7 = (PLFLT *) 0 ;
13319  Matrix temp1 ;
13320  Matrix temp2 ;
13321  double val5 ;
13322  int ecode5 = 0 ;
13323  Matrix temp6 ;
13324  Matrix temp7 ;
13325  octave_value_list _out;
13326  octave_value_list *_outp=&_out;
13327  octave_value _outv;
13328 
13329  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
13330  SWIG_fail;
13331  }
13332  {
13333  if ( _n_dims( args(0) ) > 2 )
13334  {
13335  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13336  }
13337  temp1 = args(0).matrix_value();
13338  arg1 = &temp1( 0, 0 );
13339  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13340  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13341  }
13342  {
13343  if ( _n_dims( args(1) ) > 2 )
13344  {
13345  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13346  }
13347  if ( _dim( args(1), 0 ) != Xlen )
13348  {
13349  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13350  }
13351  if ( _dim( args(1), 1 ) != Ylen )
13352  {
13353  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13354  }
13355  temp2 = args(1).matrix_value();
13356  arg2 = &temp2( 0, 0 );
13357  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13358  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13359  }
13360  ecode5 = SWIG_AsVal_double(args(2), &val5);
13361  if (!SWIG_IsOK(ecode5)) {
13362  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
13363  }
13364  arg5 = (PLFLT)(val5);
13365  {
13366  if ( _n_dims( args(3) ) > 2 )
13367  {
13368  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13369  }
13370  temp6 = args(3).matrix_value();
13371  arg6 = &temp6( 0, 0 );
13372  Xlen = (PLINT) ( _dim( args(3), 0 ) );
13373  Ylen = (PLINT) ( _dim( args(3), 1 ) );
13374  }
13375  {
13376  if ( _n_dims( args(4) ) > 2 )
13377  {
13378  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13379  }
13380  temp7 = args(4).matrix_value();
13381  arg7 = &temp7( 0, 0 );
13382  Xlen = (PLINT) ( _dim( args(4), 0 ) );
13383  Ylen = (PLINT) ( _dim( args(4), 1 ) );
13384  }
13385  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
13386  _outv = octave_value();
13387  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13388  {
13389 
13390  }
13391  {
13392 
13393  }
13394  {
13395 
13396  }
13397  {
13398 
13399  }
13400 fail:
13401  return _out;
13402 }
13403 
13404 
13405 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
13406  PLFLT *arg1 = (PLFLT *) 0 ;
13407  PLINT arg2 ;
13408  PLINT arg3 ;
13409  PLFLT arg4 ;
13410  PLFLT arg5 ;
13411  PLFLT arg6 ;
13412  PLFLT arg7 ;
13413  PLFLT arg8 ;
13414  PLFLT arg9 ;
13415  PLFLT arg10 ;
13416  PLFLT arg11 ;
13417  PLFLT arg12 ;
13418  PLFLT arg13 ;
13419  Matrix temp1 ;
13420  double val4 ;
13421  int ecode4 = 0 ;
13422  double val5 ;
13423  int ecode5 = 0 ;
13424  double val6 ;
13425  int ecode6 = 0 ;
13426  double val7 ;
13427  int ecode7 = 0 ;
13428  double val8 ;
13429  int ecode8 = 0 ;
13430  double val9 ;
13431  int ecode9 = 0 ;
13432  double val10 ;
13433  int ecode10 = 0 ;
13434  double val11 ;
13435  int ecode11 = 0 ;
13436  double val12 ;
13437  int ecode12 = 0 ;
13438  double val13 ;
13439  int ecode13 = 0 ;
13440  octave_value_list _out;
13441  octave_value_list *_outp=&_out;
13442  octave_value _outv;
13443 
13444  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
13445  SWIG_fail;
13446  }
13447  {
13448  if ( _n_dims( args(0) ) > 2 )
13449  {
13450  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13451  }
13452  temp1 = args(0).matrix_value();
13453  arg1 = &temp1( 0, 0 );
13454  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13455  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13456  }
13457  ecode4 = SWIG_AsVal_double(args(1), &val4);
13458  if (!SWIG_IsOK(ecode4)) {
13459  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
13460  }
13461  arg4 = (PLFLT)(val4);
13462  ecode5 = SWIG_AsVal_double(args(2), &val5);
13463  if (!SWIG_IsOK(ecode5)) {
13464  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
13465  }
13466  arg5 = (PLFLT)(val5);
13467  ecode6 = SWIG_AsVal_double(args(3), &val6);
13468  if (!SWIG_IsOK(ecode6)) {
13469  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
13470  }
13471  arg6 = (PLFLT)(val6);
13472  ecode7 = SWIG_AsVal_double(args(4), &val7);
13473  if (!SWIG_IsOK(ecode7)) {
13474  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
13475  }
13476  arg7 = (PLFLT)(val7);
13477  ecode8 = SWIG_AsVal_double(args(5), &val8);
13478  if (!SWIG_IsOK(ecode8)) {
13479  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
13480  }
13481  arg8 = (PLFLT)(val8);
13482  ecode9 = SWIG_AsVal_double(args(6), &val9);
13483  if (!SWIG_IsOK(ecode9)) {
13484  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
13485  }
13486  arg9 = (PLFLT)(val9);
13487  ecode10 = SWIG_AsVal_double(args(7), &val10);
13488  if (!SWIG_IsOK(ecode10)) {
13489  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
13490  }
13491  arg10 = (PLFLT)(val10);
13492  ecode11 = SWIG_AsVal_double(args(8), &val11);
13493  if (!SWIG_IsOK(ecode11)) {
13494  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
13495  }
13496  arg11 = (PLFLT)(val11);
13497  ecode12 = SWIG_AsVal_double(args(9), &val12);
13498  if (!SWIG_IsOK(ecode12)) {
13499  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
13500  }
13501  arg12 = (PLFLT)(val12);
13502  ecode13 = SWIG_AsVal_double(args(10), &val13);
13503  if (!SWIG_IsOK(ecode13)) {
13504  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
13505  }
13506  arg13 = (PLFLT)(val13);
13507  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13508  _outv = octave_value();
13509  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13510  {
13511 
13512  }
13513 fail:
13514  return _out;
13515 }
13516 
13517 
13518 SWIG_DEFUN( plimagefr, _wrap_plimagefr, _wrap_plimagefr_texinfo ) {
13519  PLFLT *arg1 = (PLFLT *) 0 ;
13520  PLINT arg2 ;
13521  PLINT arg3 ;
13522  PLFLT arg4 ;
13523  PLFLT arg5 ;
13524  PLFLT arg6 ;
13525  PLFLT arg7 ;
13526  PLFLT arg8 ;
13527  PLFLT arg9 ;
13528  PLFLT arg10 ;
13529  PLFLT arg11 ;
13530  Matrix temp1 ;
13531  double val4 ;
13532  int ecode4 = 0 ;
13533  double val5 ;
13534  int ecode5 = 0 ;
13535  double val6 ;
13536  int ecode6 = 0 ;
13537  double val7 ;
13538  int ecode7 = 0 ;
13539  double val8 ;
13540  int ecode8 = 0 ;
13541  double val9 ;
13542  int ecode9 = 0 ;
13543  double val10 ;
13544  int ecode10 = 0 ;
13545  double val11 ;
13546  int ecode11 = 0 ;
13547  octave_value_list _out;
13548  octave_value_list *_outp=&_out;
13549  octave_value _outv;
13550 
13551  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
13552  SWIG_fail;
13553  }
13554  {
13555  if ( _n_dims( args(0) ) > 2 )
13556  {
13557  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13558  }
13559  temp1 = args(0).matrix_value();
13560  arg1 = &temp1( 0, 0 );
13561  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13562  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13563  }
13564  ecode4 = SWIG_AsVal_double(args(1), &val4);
13565  if (!SWIG_IsOK(ecode4)) {
13566  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
13567  }
13568  arg4 = (PLFLT)(val4);
13569  ecode5 = SWIG_AsVal_double(args(2), &val5);
13570  if (!SWIG_IsOK(ecode5)) {
13571  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
13572  }
13573  arg5 = (PLFLT)(val5);
13574  ecode6 = SWIG_AsVal_double(args(3), &val6);
13575  if (!SWIG_IsOK(ecode6)) {
13576  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
13577  }
13578  arg6 = (PLFLT)(val6);
13579  ecode7 = SWIG_AsVal_double(args(4), &val7);
13580  if (!SWIG_IsOK(ecode7)) {
13581  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
13582  }
13583  arg7 = (PLFLT)(val7);
13584  ecode8 = SWIG_AsVal_double(args(5), &val8);
13585  if (!SWIG_IsOK(ecode8)) {
13586  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
13587  }
13588  arg8 = (PLFLT)(val8);
13589  ecode9 = SWIG_AsVal_double(args(6), &val9);
13590  if (!SWIG_IsOK(ecode9)) {
13591  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
13592  }
13593  arg9 = (PLFLT)(val9);
13594  ecode10 = SWIG_AsVal_double(args(7), &val10);
13595  if (!SWIG_IsOK(ecode10)) {
13596  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
13597  }
13598  arg10 = (PLFLT)(val10);
13599  ecode11 = SWIG_AsVal_double(args(8), &val11);
13600  if (!SWIG_IsOK(ecode11)) {
13601  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
13602  }
13603  arg11 = (PLFLT)(val11);
13604  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13605  _outv = octave_value();
13606  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13607  {
13608 
13609  }
13610 fail:
13611  return _out;
13612 }
13613 
13614 
13615 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
13616  PLFLT *arg1 = (PLFLT *) 0 ;
13617  PLINT arg2 ;
13618  PLINT arg3 ;
13619  PLFLT arg4 ;
13620  PLFLT arg5 ;
13621  PLFLT arg6 ;
13622  PLFLT arg7 ;
13623  PLFLT arg8 ;
13624  PLFLT arg9 ;
13625  PLFLT arg10 ;
13626  PLFLT arg11 ;
13627  PLFLT *arg12 = (PLFLT *) 0 ;
13628  Matrix temp1 ;
13629  double val4 ;
13630  int ecode4 = 0 ;
13631  double val5 ;
13632  int ecode5 = 0 ;
13633  double val6 ;
13634  int ecode6 = 0 ;
13635  double val7 ;
13636  int ecode7 = 0 ;
13637  double val8 ;
13638  int ecode8 = 0 ;
13639  double val9 ;
13640  int ecode9 = 0 ;
13641  double val10 ;
13642  int ecode10 = 0 ;
13643  double val11 ;
13644  int ecode11 = 0 ;
13645  Matrix temp12 ;
13646  octave_value_list _out;
13647  octave_value_list *_outp=&_out;
13648  octave_value _outv;
13649 
13650  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
13651  SWIG_fail;
13652  }
13653  {
13654  if ( _n_dims( args(0) ) > 2 )
13655  {
13656  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13657  }
13658  temp1 = args(0).matrix_value();
13659  arg1 = &temp1( 0, 0 );
13660  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13661  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13662  }
13663  ecode4 = SWIG_AsVal_double(args(1), &val4);
13664  if (!SWIG_IsOK(ecode4)) {
13665  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
13666  }
13667  arg4 = (PLFLT)(val4);
13668  ecode5 = SWIG_AsVal_double(args(2), &val5);
13669  if (!SWIG_IsOK(ecode5)) {
13670  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
13671  }
13672  arg5 = (PLFLT)(val5);
13673  ecode6 = SWIG_AsVal_double(args(3), &val6);
13674  if (!SWIG_IsOK(ecode6)) {
13675  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
13676  }
13677  arg6 = (PLFLT)(val6);
13678  ecode7 = SWIG_AsVal_double(args(4), &val7);
13679  if (!SWIG_IsOK(ecode7)) {
13680  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
13681  }
13682  arg7 = (PLFLT)(val7);
13683  ecode8 = SWIG_AsVal_double(args(5), &val8);
13684  if (!SWIG_IsOK(ecode8)) {
13685  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
13686  }
13687  arg8 = (PLFLT)(val8);
13688  ecode9 = SWIG_AsVal_double(args(6), &val9);
13689  if (!SWIG_IsOK(ecode9)) {
13690  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
13691  }
13692  arg9 = (PLFLT)(val9);
13693  ecode10 = SWIG_AsVal_double(args(7), &val10);
13694  if (!SWIG_IsOK(ecode10)) {
13695  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
13696  }
13697  arg10 = (PLFLT)(val10);
13698  ecode11 = SWIG_AsVal_double(args(8), &val11);
13699  if (!SWIG_IsOK(ecode11)) {
13700  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
13701  }
13702  arg11 = (PLFLT)(val11);
13703  {
13704  if ( _n_dims( args(9) ) > 1 )
13705  {
13706  error( "argument must be a scalar or vector" ); SWIG_fail;
13707  }
13708  if ( _dim( args(9), 0 ) != 6 )
13709  {
13710  error( "argument vectors must have length of 6" ); SWIG_fail;
13711  }
13712  temp12 = args(9).matrix_value();
13713  arg12 = &temp12( 0, 0 );
13714  }
13715  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13716  _outv = octave_value();
13717  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13718  {
13719 
13720  }
13721  {
13722 
13723  }
13724 fail:
13725  return _out;
13726 }
13727 
13728 
13729 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
13730  PLFLT *arg1 = (PLFLT *) 0 ;
13731  PLINT arg2 ;
13732  PLINT arg3 ;
13733  PLFLT arg4 ;
13734  PLFLT arg5 ;
13735  PLFLT arg6 ;
13736  PLFLT arg7 ;
13737  PLFLT arg8 ;
13738  PLFLT arg9 ;
13739  PLFLT arg10 ;
13740  PLFLT arg11 ;
13741  PLFLT *arg12 = (PLFLT *) 0 ;
13742  PLFLT *arg13 = (PLFLT *) 0 ;
13743  Matrix temp1 ;
13744  double val4 ;
13745  int ecode4 = 0 ;
13746  double val5 ;
13747  int ecode5 = 0 ;
13748  double val6 ;
13749  int ecode6 = 0 ;
13750  double val7 ;
13751  int ecode7 = 0 ;
13752  double val8 ;
13753  int ecode8 = 0 ;
13754  double val9 ;
13755  int ecode9 = 0 ;
13756  double val10 ;
13757  int ecode10 = 0 ;
13758  double val11 ;
13759  int ecode11 = 0 ;
13760  Matrix temp12 ;
13761  Matrix temp13 ;
13762  octave_value_list _out;
13763  octave_value_list *_outp=&_out;
13764  octave_value _outv;
13765 
13766  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
13767  SWIG_fail;
13768  }
13769  {
13770  if ( _n_dims( args(0) ) > 2 )
13771  {
13772  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13773  }
13774  temp1 = args(0).matrix_value();
13775  arg1 = &temp1( 0, 0 );
13776  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13777  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13778  }
13779  ecode4 = SWIG_AsVal_double(args(1), &val4);
13780  if (!SWIG_IsOK(ecode4)) {
13781  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
13782  }
13783  arg4 = (PLFLT)(val4);
13784  ecode5 = SWIG_AsVal_double(args(2), &val5);
13785  if (!SWIG_IsOK(ecode5)) {
13786  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
13787  }
13788  arg5 = (PLFLT)(val5);
13789  ecode6 = SWIG_AsVal_double(args(3), &val6);
13790  if (!SWIG_IsOK(ecode6)) {
13791  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
13792  }
13793  arg6 = (PLFLT)(val6);
13794  ecode7 = SWIG_AsVal_double(args(4), &val7);
13795  if (!SWIG_IsOK(ecode7)) {
13796  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
13797  }
13798  arg7 = (PLFLT)(val7);
13799  ecode8 = SWIG_AsVal_double(args(5), &val8);
13800  if (!SWIG_IsOK(ecode8)) {
13801  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
13802  }
13803  arg8 = (PLFLT)(val8);
13804  ecode9 = SWIG_AsVal_double(args(6), &val9);
13805  if (!SWIG_IsOK(ecode9)) {
13806  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
13807  }
13808  arg9 = (PLFLT)(val9);
13809  ecode10 = SWIG_AsVal_double(args(7), &val10);
13810  if (!SWIG_IsOK(ecode10)) {
13811  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
13812  }
13813  arg10 = (PLFLT)(val10);
13814  ecode11 = SWIG_AsVal_double(args(8), &val11);
13815  if (!SWIG_IsOK(ecode11)) {
13816  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
13817  }
13818  arg11 = (PLFLT)(val11);
13819  {
13820  if ( _n_dims( args(9) ) > 1 )
13821  {
13822  error( "argument must be a scalar or vector" ); SWIG_fail;
13823  }
13824  if ( _dim( args(9), 0 ) != Xlen )
13825  {
13826  error( "argument vectors must be same length" ); SWIG_fail;
13827  }
13828  temp12 = args(9).matrix_value();
13829  arg12 = &temp12( 0, 0 );
13830  }
13831  {
13832  if ( _n_dims( args(10) ) > 1 )
13833  {
13834  error( "argument must be a scalar or vector" ); SWIG_fail;
13835  }
13836  if ( _dim( args(10), 0 ) != Ylen )
13837  {
13838  error( "argument vectors must be same length" ); SWIG_fail;
13839  }
13840  temp13 = args(10).matrix_value();
13841  arg13 = &temp13( 0, 0 );
13842  }
13843  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
13844  _outv = octave_value();
13845  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13846  {
13847 
13848  }
13849  {
13850 
13851  }
13852  {
13853 
13854  }
13855 fail:
13856  return _out;
13857 }
13858 
13859 
13860 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
13861  PLFLT *arg1 = (PLFLT *) 0 ;
13862  PLINT arg2 ;
13863  PLINT arg3 ;
13864  PLFLT arg4 ;
13865  PLFLT arg5 ;
13866  PLFLT arg6 ;
13867  PLFLT arg7 ;
13868  PLFLT arg8 ;
13869  PLFLT arg9 ;
13870  PLFLT arg10 ;
13871  PLFLT arg11 ;
13872  PLFLT *arg12 = (PLFLT *) 0 ;
13873  PLFLT *arg13 = (PLFLT *) 0 ;
13874  Matrix temp1 ;
13875  double val4 ;
13876  int ecode4 = 0 ;
13877  double val5 ;
13878  int ecode5 = 0 ;
13879  double val6 ;
13880  int ecode6 = 0 ;
13881  double val7 ;
13882  int ecode7 = 0 ;
13883  double val8 ;
13884  int ecode8 = 0 ;
13885  double val9 ;
13886  int ecode9 = 0 ;
13887  double val10 ;
13888  int ecode10 = 0 ;
13889  double val11 ;
13890  int ecode11 = 0 ;
13891  Matrix temp12 ;
13892  Matrix temp13 ;
13893  octave_value_list _out;
13894  octave_value_list *_outp=&_out;
13895  octave_value _outv;
13896 
13897  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
13898  SWIG_fail;
13899  }
13900  {
13901  if ( _n_dims( args(0) ) > 2 )
13902  {
13903  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13904  }
13905  temp1 = args(0).matrix_value();
13906  arg1 = &temp1( 0, 0 );
13907  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13908  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13909  }
13910  ecode4 = SWIG_AsVal_double(args(1), &val4);
13911  if (!SWIG_IsOK(ecode4)) {
13912  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
13913  }
13914  arg4 = (PLFLT)(val4);
13915  ecode5 = SWIG_AsVal_double(args(2), &val5);
13916  if (!SWIG_IsOK(ecode5)) {
13917  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
13918  }
13919  arg5 = (PLFLT)(val5);
13920  ecode6 = SWIG_AsVal_double(args(3), &val6);
13921  if (!SWIG_IsOK(ecode6)) {
13922  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
13923  }
13924  arg6 = (PLFLT)(val6);
13925  ecode7 = SWIG_AsVal_double(args(4), &val7);
13926  if (!SWIG_IsOK(ecode7)) {
13927  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
13928  }
13929  arg7 = (PLFLT)(val7);
13930  ecode8 = SWIG_AsVal_double(args(5), &val8);
13931  if (!SWIG_IsOK(ecode8)) {
13932  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
13933  }
13934  arg8 = (PLFLT)(val8);
13935  ecode9 = SWIG_AsVal_double(args(6), &val9);
13936  if (!SWIG_IsOK(ecode9)) {
13937  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
13938  }
13939  arg9 = (PLFLT)(val9);
13940  ecode10 = SWIG_AsVal_double(args(7), &val10);
13941  if (!SWIG_IsOK(ecode10)) {
13942  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
13943  }
13944  arg10 = (PLFLT)(val10);
13945  ecode11 = SWIG_AsVal_double(args(8), &val11);
13946  if (!SWIG_IsOK(ecode11)) {
13947  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
13948  }
13949  arg11 = (PLFLT)(val11);
13950  {
13951  if ( _n_dims( args(9) ) > 2 )
13952  {
13953  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13954  }
13955  temp12 = args(9).matrix_value();
13956  arg12 = &temp12( 0, 0 );
13957  Xlen = (PLINT) ( _dim( args(9), 0 ) );
13958  Ylen = (PLINT) ( _dim( args(9), 1 ) );
13959  }
13960  {
13961  if ( _n_dims( args(10) ) > 2 )
13962  {
13963  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13964  }
13965  temp13 = args(10).matrix_value();
13966  arg13 = &temp13( 0, 0 );
13967  Xlen = (PLINT) ( _dim( args(10), 0 ) );
13968  Ylen = (PLINT) ( _dim( args(10), 1 ) );
13969  }
13970  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
13971  _outv = octave_value();
13972  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13973  {
13974 
13975  }
13976  {
13977 
13978  }
13979  {
13980 
13981  }
13982 fail:
13983  return _out;
13984 }
13985 
13986 
13987 SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
13988  PLFLT *arg1 = (PLFLT *) 0 ;
13989  PLFLT *arg2 = (PLFLT *) 0 ;
13990  PLINT arg3 ;
13991  PLINT arg4 ;
13992  PLFLT arg5 ;
13993  PLFLT arg6 ;
13994  PLFLT arg7 ;
13995  PLFLT arg8 ;
13996  PLINT arg9 ;
13997  PLINT arg10 ;
13998  PLINT arg11 ;
13999  PLFLT arg12 ;
14000  PLFLT arg13 ;
14001  PLINT arg14 ;
14002  PLFLT arg15 ;
14003  PLINT arg16 ;
14004  PLINT *arg17 = (PLINT *) 0 ;
14005  char **arg18 = (char **) 0 ;
14006  PLINT arg19 ;
14007  char **arg20 = (char **) 0 ;
14008  PLFLT *arg21 = (PLFLT *) 0 ;
14009  PLINT *arg22 = (PLINT *) 0 ;
14010  PLINT *arg23 = (PLINT *) 0 ;
14011  PLFLT *arg24 = (PLFLT *) 0 ;
14012  PLFLT temp1 ;
14013  int res1 = SWIG_TMPOBJ ;
14014  PLFLT temp2 ;
14015  int res2 = SWIG_TMPOBJ ;
14016  int val3 ;
14017  int ecode3 = 0 ;
14018  int val4 ;
14019  int ecode4 = 0 ;
14020  double val5 ;
14021  int ecode5 = 0 ;
14022  double val6 ;
14023  int ecode6 = 0 ;
14024  double val7 ;
14025  int ecode7 = 0 ;
14026  double val8 ;
14027  int ecode8 = 0 ;
14028  int val9 ;
14029  int ecode9 = 0 ;
14030  int val10 ;
14031  int ecode10 = 0 ;
14032  int val11 ;
14033  int ecode11 = 0 ;
14034  double val12 ;
14035  int ecode12 = 0 ;
14036  double val13 ;
14037  int ecode13 = 0 ;
14038  int val14 ;
14039  int ecode14 = 0 ;
14040  double val15 ;
14041  int ecode15 = 0 ;
14042  Matrix temp16 ;
14043  Matrix temp21 ;
14044  Matrix temp22 ;
14045  Matrix temp23 ;
14046  Matrix temp24 ;
14047  octave_value_list _out;
14048  octave_value_list *_outp=&_out;
14049  octave_value _outv;
14050 
14051  arg1 = &temp1;
14052  arg2 = &temp2;
14053  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
14054  SWIG_fail;
14055  }
14056  ecode3 = SWIG_AsVal_int(args(0), &val3);
14057  if (!SWIG_IsOK(ecode3)) {
14058  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
14059  }
14060  arg3 = (PLINT)(val3);
14061  ecode4 = SWIG_AsVal_int(args(1), &val4);
14062  if (!SWIG_IsOK(ecode4)) {
14063  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
14064  }
14065  arg4 = (PLINT)(val4);
14066  ecode5 = SWIG_AsVal_double(args(2), &val5);
14067  if (!SWIG_IsOK(ecode5)) {
14068  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
14069  }
14070  arg5 = (PLFLT)(val5);
14071  ecode6 = SWIG_AsVal_double(args(3), &val6);
14072  if (!SWIG_IsOK(ecode6)) {
14073  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
14074  }
14075  arg6 = (PLFLT)(val6);
14076  ecode7 = SWIG_AsVal_double(args(4), &val7);
14077  if (!SWIG_IsOK(ecode7)) {
14078  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
14079  }
14080  arg7 = (PLFLT)(val7);
14081  ecode8 = SWIG_AsVal_double(args(5), &val8);
14082  if (!SWIG_IsOK(ecode8)) {
14083  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
14084  }
14085  arg8 = (PLFLT)(val8);
14086  ecode9 = SWIG_AsVal_int(args(6), &val9);
14087  if (!SWIG_IsOK(ecode9)) {
14088  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
14089  }
14090  arg9 = (PLINT)(val9);
14091  ecode10 = SWIG_AsVal_int(args(7), &val10);
14092  if (!SWIG_IsOK(ecode10)) {
14093  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
14094  }
14095  arg10 = (PLINT)(val10);
14096  ecode11 = SWIG_AsVal_int(args(8), &val11);
14097  if (!SWIG_IsOK(ecode11)) {
14098  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
14099  }
14100  arg11 = (PLINT)(val11);
14101  ecode12 = SWIG_AsVal_double(args(9), &val12);
14102  if (!SWIG_IsOK(ecode12)) {
14103  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
14104  }
14105  arg12 = (PLFLT)(val12);
14106  ecode13 = SWIG_AsVal_double(args(10), &val13);
14107  if (!SWIG_IsOK(ecode13)) {
14108  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
14109  }
14110  arg13 = (PLFLT)(val13);
14111  ecode14 = SWIG_AsVal_int(args(11), &val14);
14112  if (!SWIG_IsOK(ecode14)) {
14113  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
14114  }
14115  arg14 = (PLINT)(val14);
14116  ecode15 = SWIG_AsVal_double(args(12), &val15);
14117  if (!SWIG_IsOK(ecode15)) {
14118  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
14119  }
14120  arg15 = (PLFLT)(val15);
14121  {
14122  if ( _n_dims( args(13) ) > 1 )
14123  {
14124  error( "argument must be a scalar or vector" ); SWIG_fail;
14125  }
14126  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
14127  arg17 = new PLINT[Alen];
14128  temp16 = args(13).matrix_value();
14129  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
14130  }
14131  {
14132  charMatrix temp_matrix;
14133  Cell temp_cell;
14134  char *tmp_cstring;
14135  std::string str;
14136  size_t max_length = 0, non_blank_length;
14137  int i, ifcell;
14138  if ( _n_dims( args(14) ) > 2 )
14139  {
14140  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14141  }
14142  if ( !args(14).is_empty() )
14143  {
14144  if ( _dim( args(14), 0 ) != Alen )
14145  {
14146  error( "first dimension must be same length as previous vector" ); SWIG_fail;
14147  }
14148  arg18 = new char*[Alen];
14149  ifcell = args(14).is_cell();
14150  if ( ifcell )
14151  {
14152  temp_cell = args(14).cell_value();
14153  }
14154  else
14155  {
14156  temp_matrix = args(14).char_matrix_value();
14157  // Allow one extra space for null termination.
14158  max_length = _dim( args(14), 1 ) + 1;
14159  }
14160 
14161  for ( i = 0; i < Alen; i++ )
14162  {
14163  // Must copy string to "permanent" location because the string
14164  // location corresponding to tmp_cstring gets
14165  // overwritten for each iteration of loop.
14166  if ( ifcell )
14167  {
14168  if ( temp_cell.elem( i ).is_string() )
14169  {
14170  str = temp_cell.elem( i ).string_value();
14171  // leave room for null termination.
14172  max_length = str.size() + 1;
14173  tmp_cstring = (char *) str.c_str();
14174  }
14175  else
14176  {
14177  // Use null string if user attempts to pass a cell array
14178  // with a non-string element (likely an empty element
14179  // since that should be allowed by the PLplot interface
14180  // if that element is going to be unused).
14181  // leave room for null termination.
14182  max_length = 1;
14183  tmp_cstring = (char *) "";
14184  }
14185  }
14186  else
14187  {
14188  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14189  }
14190  arg18[i] = new char[max_length];
14191  strncpy( arg18[i], tmp_cstring, max_length - 1 );
14192  arg18[i][max_length - 1] = '\0';
14193  // All the trailing blank crapola should not be needed for
14194  // string cell arrays.
14195  if ( !ifcell )
14196  {
14197  // remove trailing-blank padding that is used by the
14198  // charMatrix class to insure all strings in a given
14199  // charMatrix instance have the same length.
14200  // This transformation also removes legitimate trailing
14201  // blanks but there is nothing we can do about that
14202  // for the charMatrix class.
14203 
14204  // Look for trailing nulls first (just in case, although that
14205  // shouldn't happen if charMatrix implemented as documented)
14206  // before looking for trailing blanks.
14207  non_blank_length = max_length - 2;
14208  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
14209  {
14210  non_blank_length--;
14211  }
14212  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
14213  {
14214  non_blank_length--;
14215  }
14216  arg18[i][non_blank_length + 1] = '\0';
14217  }
14218  }
14219  }
14220  else
14221  {
14222  arg18 = NULL;
14223  }
14224  }
14225  {
14226  charMatrix temp_matrix;
14227  Cell temp_cell;
14228  char *tmp_cstring;
14229  std::string str;
14230  size_t max_length = 0, non_blank_length;
14231  int i, ifcell;
14232  if ( _n_dims( args(15) ) > 2 )
14233  {
14234  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14235  }
14236  if ( !args(15).is_empty() )
14237  {
14238  Alen = _dim( args(15), 0 );
14239  arg19 = Alen;
14240  arg20 = new char*[Alen];
14241  ifcell = args(15).is_cell();
14242  if ( ifcell )
14243  {
14244  temp_cell = args(15).cell_value();
14245  }
14246  else
14247  {
14248  temp_matrix = args(15).char_matrix_value();
14249  // Allow one extra space for null termination.
14250  max_length = _dim( args(15), 1 ) + 1;
14251  }
14252 
14253  for ( i = 0; i < Alen; i++ )
14254  {
14255  // Must copy string to "permanent" location because the string
14256  // location corresponding to tmp_cstring gets
14257  // overwritten for each iteration of loop.
14258  if ( ifcell )
14259  {
14260  if ( temp_cell.elem( i ).is_string() )
14261  {
14262  str = temp_cell.elem( i ).string_value();
14263  // leave room for null termination.
14264  max_length = str.size() + 1;
14265  tmp_cstring = (char *) str.c_str();
14266  }
14267  else
14268  {
14269  // Use null string if user attempts to pass a cell array
14270  // with a non-string element (likely an empty element
14271  // since that should be allowed by the PLplot interface
14272  // if that element is going to be unused).
14273  // leave room for null termination.
14274  max_length = 1;
14275  tmp_cstring = (char *) "";
14276  }
14277  }
14278  else
14279  {
14280  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14281  }
14282  arg20[i] = new char[max_length];
14283  strncpy( arg20[i], tmp_cstring, max_length - 1 );
14284  arg20[i][max_length - 1] = '\0';
14285  // All the trailing blank crapola should not be needed for
14286  // string cell arrays.
14287  if ( !ifcell )
14288  {
14289  // remove trailing-blank padding that is used by the
14290  // charMatrix class to insure all strings in a given
14291  // charMatrix instance have the same length.
14292  // This transformation also removes legitimate trailing
14293  // blanks but there is nothing we can do about that
14294  // for the charMatrix class.
14295 
14296  // Look for trailing nulls first (just in case, although that
14297  // shouldn't happen if charMatrix implemented as documented)
14298  // before looking for trailing blanks.
14299  non_blank_length = max_length - 2;
14300  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
14301  {
14302  non_blank_length--;
14303  }
14304  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
14305  {
14306  non_blank_length--;
14307  }
14308  arg20[i][non_blank_length + 1] = '\0';
14309  }
14310  }
14311  }
14312  else
14313  {
14314  arg19 = 0;
14315  arg20 = NULL;
14316  }
14317  }
14318  {
14319  if ( _n_dims( args(16) ) > 1 )
14320  {
14321  error( "argument must be a scalar or vector" ); SWIG_fail;
14322  }
14323  if ( _dim( args(16), 0 ) != Alen )
14324  {
14325  error( "argument vectors must be same length" ); SWIG_fail;
14326  }
14327  temp21 = args(16).matrix_value();
14328  arg21 = &temp21( 0, 0 );
14329  }
14330  {
14331  if ( _n_dims( args(17) ) > 1 )
14332  {
14333  error( "argument must be a scalar or vector" ); SWIG_fail;
14334  }
14335  if ( _dim( args(17), 0 ) != Alen )
14336  {
14337  error( "argument vectors must be same length" ); SWIG_fail;
14338  }
14339  temp22 = args(17).matrix_value();
14340  arg22 = new PLINT[Alen];
14341  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
14342  }
14343  {
14344  int i;
14345  if ( _n_dims( args(18) ) > 1 )
14346  {
14347  error( "argument must be a scalar or vector" ); SWIG_fail;
14348  }
14349  if ( _dim( args(18), 0 ) != Alen )
14350  {
14351  error( "argument vectors must be same length" ); SWIG_fail;
14352  }
14353  Xlen = Alen;
14354  temp23 = args(18).matrix_value();
14355  arg23 = new PLINT[Alen];
14356  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
14357  Ylen = -1;
14358  for ( i = 0; i < Xlen; i++ )
14359  if ( arg23[i] > Ylen )
14360  Ylen = arg23[i];
14361  }
14362  {
14363  if ( _n_dims( args(19) ) > 2 )
14364  {
14365  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14366  }
14367  if ( _dim( args(19), 0 ) != Xlen )
14368  {
14369  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14370  }
14371  if ( _dim( args(19), 1 ) != Ylen )
14372  {
14373  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14374  }
14375  temp24 = args(19).matrix_value();
14376  arg24 = &temp24( 0, 0 );
14377  }
14378  my_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);
14379  _outv = octave_value();
14380  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14381  if (SWIG_IsTmpObj(res1)) {
14382  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14383  } else {
14384  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14385  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14386  }
14387  if (SWIG_IsTmpObj(res2)) {
14388  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14389  } else {
14390  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14391  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14392  }
14393  {
14394  delete [] arg17;
14395  }
14396  {
14397  int i;
14398  if ( arg18 != NULL )
14399  {
14400  for ( i = 0; i < Alen; i++ )
14401  {
14402  delete[] arg18[i];
14403  }
14404  delete[] arg18;
14405  }
14406  }
14407  {
14408  int i;
14409  if ( arg20 != NULL )
14410  {
14411  for ( i = 0; i < Alen; i++ )
14412  {
14413  delete[] arg20[i];
14414  }
14415  delete[] arg20;
14416  }
14417  }
14418  {
14419 
14420  }
14421  {
14422  delete [] arg22;
14423  }
14424  {
14425  delete [] arg23;
14426  }
14427  {
14428 
14429  }
14430 fail:
14431  return _out;
14432 }
14433 
14434 
14435 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
14436  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14437  int arg2 ;
14438  void *argp1 = 0 ;
14439  int res1 = 0 ;
14440  int val2 ;
14441  int ecode2 = 0 ;
14442  octave_value_list _out;
14443  octave_value_list *_outp=&_out;
14444  octave_value _outv;
14445 
14446  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
14447  SWIG_fail;
14448  }
14449  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14450  if (!SWIG_IsOK(res1)) {
14451  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14452  }
14453  arg1 = (PLGraphicsIn *)(argp1);
14454  ecode2 = SWIG_AsVal_int(args(1), &val2);
14455  if (!SWIG_IsOK(ecode2)) {
14456  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
14457  }
14458  arg2 = (int)(val2);
14459  if (arg1) (arg1)->type = arg2;
14460  _outv = octave_value();
14461  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14462 fail:
14463  return _out;
14464 }
14465 
14466 
14467 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
14468  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14469  void *argp1 = 0 ;
14470  int res1 = 0 ;
14471  octave_value_list _out;
14472  octave_value_list *_outp=&_out;
14473  octave_value _outv;
14474  int result;
14475 
14476  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
14477  SWIG_fail;
14478  }
14479  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14480  if (!SWIG_IsOK(res1)) {
14481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14482  }
14483  arg1 = (PLGraphicsIn *)(argp1);
14484  result = (int) ((arg1)->type);
14485  _outv = SWIG_From_int((int)(result));
14486  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14487 fail:
14488  return _out;
14489 }
14490 
14491 
14492 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
14493  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14494  unsigned int arg2 ;
14495  void *argp1 = 0 ;
14496  int res1 = 0 ;
14497  unsigned int val2 ;
14498  int ecode2 = 0 ;
14499  octave_value_list _out;
14500  octave_value_list *_outp=&_out;
14501  octave_value _outv;
14502 
14503  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
14504  SWIG_fail;
14505  }
14506  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14507  if (!SWIG_IsOK(res1)) {
14508  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14509  }
14510  arg1 = (PLGraphicsIn *)(argp1);
14511  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14512  if (!SWIG_IsOK(ecode2)) {
14513  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
14514  }
14515  arg2 = (unsigned int)(val2);
14516  if (arg1) (arg1)->state = arg2;
14517  _outv = octave_value();
14518  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14519 fail:
14520  return _out;
14521 }
14522 
14523 
14524 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
14525  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14526  void *argp1 = 0 ;
14527  int res1 = 0 ;
14528  octave_value_list _out;
14529  octave_value_list *_outp=&_out;
14530  octave_value _outv;
14531  unsigned int result;
14532 
14533  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
14534  SWIG_fail;
14535  }
14536  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14537  if (!SWIG_IsOK(res1)) {
14538  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14539  }
14540  arg1 = (PLGraphicsIn *)(argp1);
14541  result = (unsigned int) ((arg1)->state);
14542  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14543  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14544 fail:
14545  return _out;
14546 }
14547 
14548 
14549 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
14550  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14551  unsigned int arg2 ;
14552  void *argp1 = 0 ;
14553  int res1 = 0 ;
14554  unsigned int val2 ;
14555  int ecode2 = 0 ;
14556  octave_value_list _out;
14557  octave_value_list *_outp=&_out;
14558  octave_value _outv;
14559 
14560  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
14561  SWIG_fail;
14562  }
14563  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14564  if (!SWIG_IsOK(res1)) {
14565  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14566  }
14567  arg1 = (PLGraphicsIn *)(argp1);
14568  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14569  if (!SWIG_IsOK(ecode2)) {
14570  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
14571  }
14572  arg2 = (unsigned int)(val2);
14573  if (arg1) (arg1)->keysym = arg2;
14574  _outv = octave_value();
14575  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14576 fail:
14577  return _out;
14578 }
14579 
14580 
14581 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
14582  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14583  void *argp1 = 0 ;
14584  int res1 = 0 ;
14585  octave_value_list _out;
14586  octave_value_list *_outp=&_out;
14587  octave_value _outv;
14588  unsigned int result;
14589 
14590  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
14591  SWIG_fail;
14592  }
14593  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14594  if (!SWIG_IsOK(res1)) {
14595  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14596  }
14597  arg1 = (PLGraphicsIn *)(argp1);
14598  result = (unsigned int) ((arg1)->keysym);
14599  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14600  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14601 fail:
14602  return _out;
14603 }
14604 
14605 
14606 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
14607  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14608  unsigned int arg2 ;
14609  void *argp1 = 0 ;
14610  int res1 = 0 ;
14611  unsigned int val2 ;
14612  int ecode2 = 0 ;
14613  octave_value_list _out;
14614  octave_value_list *_outp=&_out;
14615  octave_value _outv;
14616 
14617  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
14618  SWIG_fail;
14619  }
14620  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14621  if (!SWIG_IsOK(res1)) {
14622  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14623  }
14624  arg1 = (PLGraphicsIn *)(argp1);
14625  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14626  if (!SWIG_IsOK(ecode2)) {
14627  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
14628  }
14629  arg2 = (unsigned int)(val2);
14630  if (arg1) (arg1)->button = arg2;
14631  _outv = octave_value();
14632  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14633 fail:
14634  return _out;
14635 }
14636 
14637 
14638 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
14639  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14640  void *argp1 = 0 ;
14641  int res1 = 0 ;
14642  octave_value_list _out;
14643  octave_value_list *_outp=&_out;
14644  octave_value _outv;
14645  unsigned int result;
14646 
14647  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
14648  SWIG_fail;
14649  }
14650  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14651  if (!SWIG_IsOK(res1)) {
14652  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14653  }
14654  arg1 = (PLGraphicsIn *)(argp1);
14655  result = (unsigned int) ((arg1)->button);
14656  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14657  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14658 fail:
14659  return _out;
14660 }
14661 
14662 
14663 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
14664  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14665  PLINT arg2 ;
14666  void *argp1 = 0 ;
14667  int res1 = 0 ;
14668  int val2 ;
14669  int ecode2 = 0 ;
14670  octave_value_list _out;
14671  octave_value_list *_outp=&_out;
14672  octave_value _outv;
14673 
14674  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
14675  SWIG_fail;
14676  }
14677  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14678  if (!SWIG_IsOK(res1)) {
14679  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14680  }
14681  arg1 = (PLGraphicsIn *)(argp1);
14682  ecode2 = SWIG_AsVal_int(args(1), &val2);
14683  if (!SWIG_IsOK(ecode2)) {
14684  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
14685  }
14686  arg2 = (PLINT)(val2);
14687  if (arg1) (arg1)->subwindow = arg2;
14688  _outv = octave_value();
14689  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14690 fail:
14691  return _out;
14692 }
14693 
14694 
14695 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
14696  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14697  void *argp1 = 0 ;
14698  int res1 = 0 ;
14699  octave_value_list _out;
14700  octave_value_list *_outp=&_out;
14701  octave_value _outv;
14702  PLINT result;
14703 
14704  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
14705  SWIG_fail;
14706  }
14707  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14708  if (!SWIG_IsOK(res1)) {
14709  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14710  }
14711  arg1 = (PLGraphicsIn *)(argp1);
14712  result = (PLINT) ((arg1)->subwindow);
14713  _outv = SWIG_From_int((int)(result));
14714  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14715 fail:
14716  return _out;
14717 }
14718 
14719 
14720 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
14721  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14722  char *arg2 ;
14723  void *argp1 = 0 ;
14724  int res1 = 0 ;
14725  char temp2[16] ;
14726  int res2 ;
14727  octave_value_list _out;
14728  octave_value_list *_outp=&_out;
14729  octave_value _outv;
14730 
14731  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
14732  SWIG_fail;
14733  }
14734  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14735  if (!SWIG_IsOK(res1)) {
14736  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14737  }
14738  arg1 = (PLGraphicsIn *)(argp1);
14739  res2 = SWIG_AsCharArray(args(1), temp2, 16);
14740  if (!SWIG_IsOK(res2)) {
14741  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
14742  }
14743  arg2 = (char *)(temp2);
14744  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
14745  else memset(arg1->string,0,16*sizeof(char));
14746  _outv = octave_value();
14747  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14748 fail:
14749  return _out;
14750 }
14751 
14752 
14753 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
14754  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14755  void *argp1 = 0 ;
14756  int res1 = 0 ;
14757  octave_value_list _out;
14758  octave_value_list *_outp=&_out;
14759  octave_value _outv;
14760  char *result = 0 ;
14761 
14762  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
14763  SWIG_fail;
14764  }
14765  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14766  if (!SWIG_IsOK(res1)) {
14767  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14768  }
14769  arg1 = (PLGraphicsIn *)(argp1);
14770  result = (char *)(char *) ((arg1)->string);
14771  {
14772  size_t size = 16;
14773 
14774  while (size && (result[size - 1] == '\0')) --size;
14775 
14776  _outv = SWIG_FromCharPtrAndSize(result, size);
14777  }
14778  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14779 fail:
14780  return _out;
14781 }
14782 
14783 
14784 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
14785  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14786  int arg2 ;
14787  void *argp1 = 0 ;
14788  int res1 = 0 ;
14789  int val2 ;
14790  int ecode2 = 0 ;
14791  octave_value_list _out;
14792  octave_value_list *_outp=&_out;
14793  octave_value _outv;
14794 
14795  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
14796  SWIG_fail;
14797  }
14798  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14799  if (!SWIG_IsOK(res1)) {
14800  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14801  }
14802  arg1 = (PLGraphicsIn *)(argp1);
14803  ecode2 = SWIG_AsVal_int(args(1), &val2);
14804  if (!SWIG_IsOK(ecode2)) {
14805  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
14806  }
14807  arg2 = (int)(val2);
14808  if (arg1) (arg1)->pX = arg2;
14809  _outv = octave_value();
14810  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14811 fail:
14812  return _out;
14813 }
14814 
14815 
14816 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
14817  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14818  void *argp1 = 0 ;
14819  int res1 = 0 ;
14820  octave_value_list _out;
14821  octave_value_list *_outp=&_out;
14822  octave_value _outv;
14823  int result;
14824 
14825  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
14826  SWIG_fail;
14827  }
14828  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14829  if (!SWIG_IsOK(res1)) {
14830  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14831  }
14832  arg1 = (PLGraphicsIn *)(argp1);
14833  result = (int) ((arg1)->pX);
14834  _outv = SWIG_From_int((int)(result));
14835  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14836 fail:
14837  return _out;
14838 }
14839 
14840 
14841 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
14842  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14843  int arg2 ;
14844  void *argp1 = 0 ;
14845  int res1 = 0 ;
14846  int val2 ;
14847  int ecode2 = 0 ;
14848  octave_value_list _out;
14849  octave_value_list *_outp=&_out;
14850  octave_value _outv;
14851 
14852  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
14853  SWIG_fail;
14854  }
14855  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14856  if (!SWIG_IsOK(res1)) {
14857  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14858  }
14859  arg1 = (PLGraphicsIn *)(argp1);
14860  ecode2 = SWIG_AsVal_int(args(1), &val2);
14861  if (!SWIG_IsOK(ecode2)) {
14862  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
14863  }
14864  arg2 = (int)(val2);
14865  if (arg1) (arg1)->pY = arg2;
14866  _outv = octave_value();
14867  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14868 fail:
14869  return _out;
14870 }
14871 
14872 
14873 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
14874  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14875  void *argp1 = 0 ;
14876  int res1 = 0 ;
14877  octave_value_list _out;
14878  octave_value_list *_outp=&_out;
14879  octave_value _outv;
14880  int result;
14881 
14882  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
14883  SWIG_fail;
14884  }
14885  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14886  if (!SWIG_IsOK(res1)) {
14887  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14888  }
14889  arg1 = (PLGraphicsIn *)(argp1);
14890  result = (int) ((arg1)->pY);
14891  _outv = SWIG_From_int((int)(result));
14892  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14893 fail:
14894  return _out;
14895 }
14896 
14897 
14898 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
14899  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14900  PLFLT arg2 ;
14901  void *argp1 = 0 ;
14902  int res1 = 0 ;
14903  double val2 ;
14904  int ecode2 = 0 ;
14905  octave_value_list _out;
14906  octave_value_list *_outp=&_out;
14907  octave_value _outv;
14908 
14909  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
14910  SWIG_fail;
14911  }
14912  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14913  if (!SWIG_IsOK(res1)) {
14914  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14915  }
14916  arg1 = (PLGraphicsIn *)(argp1);
14917  ecode2 = SWIG_AsVal_double(args(1), &val2);
14918  if (!SWIG_IsOK(ecode2)) {
14919  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
14920  }
14921  arg2 = (PLFLT)(val2);
14922  if (arg1) (arg1)->dX = arg2;
14923  _outv = octave_value();
14924  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14925 fail:
14926  return _out;
14927 }
14928 
14929 
14930 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
14931  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14932  void *argp1 = 0 ;
14933  int res1 = 0 ;
14934  octave_value_list _out;
14935  octave_value_list *_outp=&_out;
14936  octave_value _outv;
14937  PLFLT result;
14938 
14939  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
14940  SWIG_fail;
14941  }
14942  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14943  if (!SWIG_IsOK(res1)) {
14944  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14945  }
14946  arg1 = (PLGraphicsIn *)(argp1);
14947  result = (PLFLT) ((arg1)->dX);
14948  _outv = SWIG_From_double((double)(result));
14949  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14950 fail:
14951  return _out;
14952 }
14953 
14954 
14955 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
14956  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14957  PLFLT arg2 ;
14958  void *argp1 = 0 ;
14959  int res1 = 0 ;
14960  double val2 ;
14961  int ecode2 = 0 ;
14962  octave_value_list _out;
14963  octave_value_list *_outp=&_out;
14964  octave_value _outv;
14965 
14966  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
14967  SWIG_fail;
14968  }
14969  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14970  if (!SWIG_IsOK(res1)) {
14971  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14972  }
14973  arg1 = (PLGraphicsIn *)(argp1);
14974  ecode2 = SWIG_AsVal_double(args(1), &val2);
14975  if (!SWIG_IsOK(ecode2)) {
14976  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
14977  }
14978  arg2 = (PLFLT)(val2);
14979  if (arg1) (arg1)->dY = arg2;
14980  _outv = octave_value();
14981  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14982 fail:
14983  return _out;
14984 }
14985 
14986 
14987 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
14988  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14989  void *argp1 = 0 ;
14990  int res1 = 0 ;
14991  octave_value_list _out;
14992  octave_value_list *_outp=&_out;
14993  octave_value _outv;
14994  PLFLT result;
14995 
14996  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
14997  SWIG_fail;
14998  }
14999  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15000  if (!SWIG_IsOK(res1)) {
15001  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15002  }
15003  arg1 = (PLGraphicsIn *)(argp1);
15004  result = (PLFLT) ((arg1)->dY);
15005  _outv = SWIG_From_double((double)(result));
15006  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15007 fail:
15008  return _out;
15009 }
15010 
15011 
15012 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
15013  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15014  PLFLT arg2 ;
15015  void *argp1 = 0 ;
15016  int res1 = 0 ;
15017  double val2 ;
15018  int ecode2 = 0 ;
15019  octave_value_list _out;
15020  octave_value_list *_outp=&_out;
15021  octave_value _outv;
15022 
15023  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
15024  SWIG_fail;
15025  }
15026  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15027  if (!SWIG_IsOK(res1)) {
15028  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15029  }
15030  arg1 = (PLGraphicsIn *)(argp1);
15031  ecode2 = SWIG_AsVal_double(args(1), &val2);
15032  if (!SWIG_IsOK(ecode2)) {
15033  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
15034  }
15035  arg2 = (PLFLT)(val2);
15036  if (arg1) (arg1)->wX = arg2;
15037  _outv = octave_value();
15038  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15039 fail:
15040  return _out;
15041 }
15042 
15043 
15044 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
15045  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15046  void *argp1 = 0 ;
15047  int res1 = 0 ;
15048  octave_value_list _out;
15049  octave_value_list *_outp=&_out;
15050  octave_value _outv;
15051  PLFLT result;
15052 
15053  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
15054  SWIG_fail;
15055  }
15056  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15057  if (!SWIG_IsOK(res1)) {
15058  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15059  }
15060  arg1 = (PLGraphicsIn *)(argp1);
15061  result = (PLFLT) ((arg1)->wX);
15062  _outv = SWIG_From_double((double)(result));
15063  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15064 fail:
15065  return _out;
15066 }
15067 
15068 
15069 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
15070  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15071  PLFLT arg2 ;
15072  void *argp1 = 0 ;
15073  int res1 = 0 ;
15074  double val2 ;
15075  int ecode2 = 0 ;
15076  octave_value_list _out;
15077  octave_value_list *_outp=&_out;
15078  octave_value _outv;
15079 
15080  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
15081  SWIG_fail;
15082  }
15083  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15084  if (!SWIG_IsOK(res1)) {
15085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15086  }
15087  arg1 = (PLGraphicsIn *)(argp1);
15088  ecode2 = SWIG_AsVal_double(args(1), &val2);
15089  if (!SWIG_IsOK(ecode2)) {
15090  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
15091  }
15092  arg2 = (PLFLT)(val2);
15093  if (arg1) (arg1)->wY = arg2;
15094  _outv = octave_value();
15095  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15096 fail:
15097  return _out;
15098 }
15099 
15100 
15101 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
15102  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15103  void *argp1 = 0 ;
15104  int res1 = 0 ;
15105  octave_value_list _out;
15106  octave_value_list *_outp=&_out;
15107  octave_value _outv;
15108  PLFLT result;
15109 
15110  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
15111  SWIG_fail;
15112  }
15113  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15114  if (!SWIG_IsOK(res1)) {
15115  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15116  }
15117  arg1 = (PLGraphicsIn *)(argp1);
15118  result = (PLFLT) ((arg1)->wY);
15119  _outv = SWIG_From_double((double)(result));
15120  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15121 fail:
15122  return _out;
15123 }
15124 
15125 
15126 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
15127  octave_value_list _out;
15128  octave_value_list *_outp=&_out;
15129  octave_value _outv;
15130  PLGraphicsIn *result = 0 ;
15131 
15132  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
15133  SWIG_fail;
15134  }
15135  result = (PLGraphicsIn *)new PLGraphicsIn();
15137  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15138 fail:
15139  return _out;
15140 }
15141 
15142 
15143 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
15144  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15145  void *argp1 = 0 ;
15146  int res1 = 0 ;
15147  octave_value_list _out;
15148  octave_value_list *_outp=&_out;
15149  octave_value _outv;
15150 
15151  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
15152  SWIG_fail;
15153  }
15154  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
15155  if (!SWIG_IsOK(res1)) {
15156  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15157  }
15158  arg1 = (PLGraphicsIn *)(argp1);
15159  delete arg1;
15160  _outv = octave_value();
15161  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15162 fail:
15163  return _out;
15164 }
15165 
15166 
15180 {0,0,0,0}
15181 };
15182 static const char *swig_PLGraphicsIn_base_names[] = {0};
15185 
15186 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
15187  PLINT arg1 ;
15188  PLINT arg2 ;
15189  int val1 ;
15190  int ecode1 = 0 ;
15191  int val2 ;
15192  int ecode2 = 0 ;
15193  octave_value_list _out;
15194  octave_value_list *_outp=&_out;
15195  octave_value _outv;
15196 
15197  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
15198  SWIG_fail;
15199  }
15200  ecode1 = SWIG_AsVal_int(args(0), &val1);
15201  if (!SWIG_IsOK(ecode1)) {
15202  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
15203  }
15204  arg1 = (PLINT)(val1);
15205  ecode2 = SWIG_AsVal_int(args(1), &val2);
15206  if (!SWIG_IsOK(ecode2)) {
15207  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
15208  }
15209  arg2 = (PLINT)(val2);
15210  pl_setcontlabelformat(arg1,arg2);
15211  _outv = octave_value();
15212  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15213 fail:
15214  return _out;
15215 }
15216 
15217 
15218 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
15219  PLFLT arg1 ;
15220  PLFLT arg2 ;
15221  PLFLT arg3 ;
15222  PLINT arg4 ;
15223  double val1 ;
15224  int ecode1 = 0 ;
15225  double val2 ;
15226  int ecode2 = 0 ;
15227  double val3 ;
15228  int ecode3 = 0 ;
15229  int val4 ;
15230  int ecode4 = 0 ;
15231  octave_value_list _out;
15232  octave_value_list *_outp=&_out;
15233  octave_value _outv;
15234 
15235  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
15236  SWIG_fail;
15237  }
15238  ecode1 = SWIG_AsVal_double(args(0), &val1);
15239  if (!SWIG_IsOK(ecode1)) {
15240  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
15241  }
15242  arg1 = (PLFLT)(val1);
15243  ecode2 = SWIG_AsVal_double(args(1), &val2);
15244  if (!SWIG_IsOK(ecode2)) {
15245  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
15246  }
15247  arg2 = (PLFLT)(val2);
15248  ecode3 = SWIG_AsVal_double(args(2), &val3);
15249  if (!SWIG_IsOK(ecode3)) {
15250  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
15251  }
15252  arg3 = (PLFLT)(val3);
15253  ecode4 = SWIG_AsVal_int(args(3), &val4);
15254  if (!SWIG_IsOK(ecode4)) {
15255  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
15256  }
15257  arg4 = (PLINT)(val4);
15258  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
15259  _outv = octave_value();
15260  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15261 fail:
15262  return _out;
15263 }
15264 
15265 
15266 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
15267  PLINT arg1 ;
15268  int val1 ;
15269  int ecode1 = 0 ;
15270  octave_value_list _out;
15271  octave_value_list *_outp=&_out;
15272  octave_value _outv;
15273 
15274  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
15275  SWIG_fail;
15276  }
15277  ecode1 = SWIG_AsVal_int(args(0), &val1);
15278  if (!SWIG_IsOK(ecode1)) {
15279  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
15280  }
15281  arg1 = (PLINT)(val1);
15282  pladv(arg1);
15283  _outv = octave_value();
15284  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15285 fail:
15286  return _out;
15287 }
15288 
15289 
15290 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
15291  PLFLT arg1 ;
15292  PLFLT arg2 ;
15293  PLFLT arg3 ;
15294  PLFLT arg4 ;
15295  PLFLT arg5 ;
15296  PLFLT arg6 ;
15297  PLFLT arg7 ;
15298  PLBOOL arg8 ;
15299  double val1 ;
15300  int ecode1 = 0 ;
15301  double val2 ;
15302  int ecode2 = 0 ;
15303  double val3 ;
15304  int ecode3 = 0 ;
15305  double val4 ;
15306  int ecode4 = 0 ;
15307  double val5 ;
15308  int ecode5 = 0 ;
15309  double val6 ;
15310  int ecode6 = 0 ;
15311  double val7 ;
15312  int ecode7 = 0 ;
15313  int val8 ;
15314  int ecode8 = 0 ;
15315  octave_value_list _out;
15316  octave_value_list *_outp=&_out;
15317  octave_value _outv;
15318 
15319  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
15320  SWIG_fail;
15321  }
15322  ecode1 = SWIG_AsVal_double(args(0), &val1);
15323  if (!SWIG_IsOK(ecode1)) {
15324  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
15325  }
15326  arg1 = (PLFLT)(val1);
15327  ecode2 = SWIG_AsVal_double(args(1), &val2);
15328  if (!SWIG_IsOK(ecode2)) {
15329  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
15330  }
15331  arg2 = (PLFLT)(val2);
15332  ecode3 = SWIG_AsVal_double(args(2), &val3);
15333  if (!SWIG_IsOK(ecode3)) {
15334  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
15335  }
15336  arg3 = (PLFLT)(val3);
15337  ecode4 = SWIG_AsVal_double(args(3), &val4);
15338  if (!SWIG_IsOK(ecode4)) {
15339  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
15340  }
15341  arg4 = (PLFLT)(val4);
15342  ecode5 = SWIG_AsVal_double(args(4), &val5);
15343  if (!SWIG_IsOK(ecode5)) {
15344  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
15345  }
15346  arg5 = (PLFLT)(val5);
15347  ecode6 = SWIG_AsVal_double(args(5), &val6);
15348  if (!SWIG_IsOK(ecode6)) {
15349  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
15350  }
15351  arg6 = (PLFLT)(val6);
15352  ecode7 = SWIG_AsVal_double(args(6), &val7);
15353  if (!SWIG_IsOK(ecode7)) {
15354  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
15355  }
15356  arg7 = (PLFLT)(val7);
15357  ecode8 = SWIG_AsVal_int(args(7), &val8);
15358  if (!SWIG_IsOK(ecode8)) {
15359  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
15360  }
15361  arg8 = (PLBOOL)(val8);
15362  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15363  _outv = octave_value();
15364  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15365 fail:
15366  return _out;
15367 }
15368 
15369 
15370 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
15371  PLFLT arg1 ;
15372  PLFLT arg2 ;
15373  char *arg3 = (char *) 0 ;
15374  PLFLT arg4 ;
15375  PLINT arg5 ;
15376  char *arg6 = (char *) 0 ;
15377  PLFLT arg7 ;
15378  PLINT arg8 ;
15379  double val1 ;
15380  int ecode1 = 0 ;
15381  double val2 ;
15382  int ecode2 = 0 ;
15383  int res3 ;
15384  char *buf3 = 0 ;
15385  int alloc3 = 0 ;
15386  double val4 ;
15387  int ecode4 = 0 ;
15388  int val5 ;
15389  int ecode5 = 0 ;
15390  int res6 ;
15391  char *buf6 = 0 ;
15392  int alloc6 = 0 ;
15393  double val7 ;
15394  int ecode7 = 0 ;
15395  int val8 ;
15396  int ecode8 = 0 ;
15397  octave_value_list _out;
15398  octave_value_list *_outp=&_out;
15399  octave_value _outv;
15400 
15401  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
15402  SWIG_fail;
15403  }
15404  ecode1 = SWIG_AsVal_double(args(0), &val1);
15405  if (!SWIG_IsOK(ecode1)) {
15406  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
15407  }
15408  arg1 = (PLFLT)(val1);
15409  ecode2 = SWIG_AsVal_double(args(1), &val2);
15410  if (!SWIG_IsOK(ecode2)) {
15411  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
15412  }
15413  arg2 = (PLFLT)(val2);
15414  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
15415  if (!SWIG_IsOK(res3)) {
15416  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
15417  }
15418  arg3 = (char *)(buf3);
15419  ecode4 = SWIG_AsVal_double(args(3), &val4);
15420  if (!SWIG_IsOK(ecode4)) {
15421  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
15422  }
15423  arg4 = (PLFLT)(val4);
15424  ecode5 = SWIG_AsVal_int(args(4), &val5);
15425  if (!SWIG_IsOK(ecode5)) {
15426  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
15427  }
15428  arg5 = (PLINT)(val5);
15429  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
15430  if (!SWIG_IsOK(res6)) {
15431  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
15432  }
15433  arg6 = (char *)(buf6);
15434  ecode7 = SWIG_AsVal_double(args(6), &val7);
15435  if (!SWIG_IsOK(ecode7)) {
15436  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
15437  }
15438  arg7 = (PLFLT)(val7);
15439  ecode8 = SWIG_AsVal_int(args(7), &val8);
15440  if (!SWIG_IsOK(ecode8)) {
15441  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
15442  }
15443  arg8 = (PLINT)(val8);
15444  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
15445  _outv = octave_value();
15446  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15447  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15448  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
15449 fail:
15450  return _out;
15451 }
15452 
15453 
15454 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
15455  PLINT arg1 ;
15456  PLFLT *arg2 = (PLFLT *) 0 ;
15457  PLFLT *arg3 = (PLFLT *) 0 ;
15458  PLINT arg4 ;
15459  Matrix temp1 ;
15460  Matrix temp3 ;
15461  int val4 ;
15462  int ecode4 = 0 ;
15463  octave_value_list _out;
15464  octave_value_list *_outp=&_out;
15465  octave_value _outv;
15466 
15467  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
15468  SWIG_fail;
15469  }
15470  {
15471  if ( _n_dims( args(0) ) > 1 )
15472  {
15473  error( "argument must be a scalar or vector" ); SWIG_fail;
15474  }
15475  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
15476  temp1 = args(0).matrix_value();
15477  arg2 = &temp1( 0, 0 );
15478  }
15479  {
15480  if ( _n_dims( args(1) ) > 1 )
15481  {
15482  error( "argument must be a scalar or vector" ); SWIG_fail;
15483  }
15484  if ( _dim( args(1), 0 ) != Alen )
15485  {
15486  error( "argument vectors must be same length" ); SWIG_fail;
15487  }
15488  temp3 = args(1).matrix_value();
15489  arg3 = &temp3( 0, 0 );
15490  }
15491  ecode4 = SWIG_AsVal_int(args(2), &val4);
15492  if (!SWIG_IsOK(ecode4)) {
15493  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
15494  }
15495  arg4 = (PLINT)(val4);
15496  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
15497  _outv = octave_value();
15498  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15499  {
15500 
15501  }
15502  {
15503 
15504  }
15505 fail:
15506  return _out;
15507 }
15508 
15509 
15510 SWIG_DEFUN( plbtime, _wrap_plbtime, _wrap_plbtime_texinfo ) {
15511  PLINT *arg1 = (PLINT *) 0 ;
15512  PLINT *arg2 = (PLINT *) 0 ;
15513  PLINT *arg3 = (PLINT *) 0 ;
15514  PLINT *arg4 = (PLINT *) 0 ;
15515  PLINT *arg5 = (PLINT *) 0 ;
15516  PLFLT *arg6 = (PLFLT *) 0 ;
15517  PLFLT arg7 ;
15518  PLINT temp1 ;
15519  int res1 = SWIG_TMPOBJ ;
15520  PLINT temp2 ;
15521  int res2 = SWIG_TMPOBJ ;
15522  PLINT temp3 ;
15523  int res3 = SWIG_TMPOBJ ;
15524  PLINT temp4 ;
15525  int res4 = SWIG_TMPOBJ ;
15526  PLINT temp5 ;
15527  int res5 = SWIG_TMPOBJ ;
15528  PLFLT temp6 ;
15529  int res6 = SWIG_TMPOBJ ;
15530  double val7 ;
15531  int ecode7 = 0 ;
15532  octave_value_list _out;
15533  octave_value_list *_outp=&_out;
15534  octave_value _outv;
15535 
15536  arg1 = &temp1;
15537  arg2 = &temp2;
15538  arg3 = &temp3;
15539  arg4 = &temp4;
15540  arg5 = &temp5;
15541  arg6 = &temp6;
15542  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
15543  SWIG_fail;
15544  }
15545  ecode7 = SWIG_AsVal_double(args(0), &val7);
15546  if (!SWIG_IsOK(ecode7)) {
15547  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
15548  }
15549  arg7 = (PLFLT)(val7);
15550  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
15551  _outv = octave_value();
15552  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15553  if (SWIG_IsTmpObj(res1)) {
15554  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15555  } else {
15556  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15557  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15558  }
15559  if (SWIG_IsTmpObj(res2)) {
15560  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15561  } else {
15562  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15563  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15564  }
15565  if (SWIG_IsTmpObj(res3)) {
15566  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15567  } else {
15568  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15569  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15570  }
15571  if (SWIG_IsTmpObj(res4)) {
15572  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15573  } else {
15574  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15575  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15576  }
15577  if (SWIG_IsTmpObj(res5)) {
15578  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15579  } else {
15580  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15581  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15582  }
15583  if (SWIG_IsTmpObj(res6)) {
15584  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
15585  } else {
15586  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15587  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
15588  }
15589 fail:
15590  return _out;
15591 }
15592 
15593 
15594 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
15595  octave_value_list _out;
15596  octave_value_list *_outp=&_out;
15597  octave_value _outv;
15598 
15599  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
15600  SWIG_fail;
15601  }
15602  plbop();
15603  _outv = octave_value();
15604  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15605 fail:
15606  return _out;
15607 }
15608 
15609 
15610 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
15611  char *arg1 = (char *) 0 ;
15612  PLFLT arg2 ;
15613  PLINT arg3 ;
15614  char *arg4 = (char *) 0 ;
15615  PLFLT arg5 ;
15616  PLINT arg6 ;
15617  int res1 ;
15618  char *buf1 = 0 ;
15619  int alloc1 = 0 ;
15620  double val2 ;
15621  int ecode2 = 0 ;
15622  int val3 ;
15623  int ecode3 = 0 ;
15624  int res4 ;
15625  char *buf4 = 0 ;
15626  int alloc4 = 0 ;
15627  double val5 ;
15628  int ecode5 = 0 ;
15629  int val6 ;
15630  int ecode6 = 0 ;
15631  octave_value_list _out;
15632  octave_value_list *_outp=&_out;
15633  octave_value _outv;
15634 
15635  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
15636  SWIG_fail;
15637  }
15638  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15639  if (!SWIG_IsOK(res1)) {
15640  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
15641  }
15642  arg1 = (char *)(buf1);
15643  ecode2 = SWIG_AsVal_double(args(1), &val2);
15644  if (!SWIG_IsOK(ecode2)) {
15645  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
15646  }
15647  arg2 = (PLFLT)(val2);
15648  ecode3 = SWIG_AsVal_int(args(2), &val3);
15649  if (!SWIG_IsOK(ecode3)) {
15650  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
15651  }
15652  arg3 = (PLINT)(val3);
15653  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
15654  if (!SWIG_IsOK(res4)) {
15655  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
15656  }
15657  arg4 = (char *)(buf4);
15658  ecode5 = SWIG_AsVal_double(args(4), &val5);
15659  if (!SWIG_IsOK(ecode5)) {
15660  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
15661  }
15662  arg5 = (PLFLT)(val5);
15663  ecode6 = SWIG_AsVal_int(args(5), &val6);
15664  if (!SWIG_IsOK(ecode6)) {
15665  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
15666  }
15667  arg6 = (PLINT)(val6);
15668  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
15669  _outv = octave_value();
15670  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15671  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15672  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15673 fail:
15674  return _out;
15675 }
15676 
15677 
15678 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
15679  char *arg1 = (char *) 0 ;
15680  char *arg2 = (char *) 0 ;
15681  PLFLT arg3 ;
15682  PLINT arg4 ;
15683  char *arg5 = (char *) 0 ;
15684  char *arg6 = (char *) 0 ;
15685  PLFLT arg7 ;
15686  PLINT arg8 ;
15687  char *arg9 = (char *) 0 ;
15688  char *arg10 = (char *) 0 ;
15689  PLFLT arg11 ;
15690  PLINT arg12 ;
15691  int res1 ;
15692  char *buf1 = 0 ;
15693  int alloc1 = 0 ;
15694  int res2 ;
15695  char *buf2 = 0 ;
15696  int alloc2 = 0 ;
15697  double val3 ;
15698  int ecode3 = 0 ;
15699  int val4 ;
15700  int ecode4 = 0 ;
15701  int res5 ;
15702  char *buf5 = 0 ;
15703  int alloc5 = 0 ;
15704  int res6 ;
15705  char *buf6 = 0 ;
15706  int alloc6 = 0 ;
15707  double val7 ;
15708  int ecode7 = 0 ;
15709  int val8 ;
15710  int ecode8 = 0 ;
15711  int res9 ;
15712  char *buf9 = 0 ;
15713  int alloc9 = 0 ;
15714  int res10 ;
15715  char *buf10 = 0 ;
15716  int alloc10 = 0 ;
15717  double val11 ;
15718  int ecode11 = 0 ;
15719  int val12 ;
15720  int ecode12 = 0 ;
15721  octave_value_list _out;
15722  octave_value_list *_outp=&_out;
15723  octave_value _outv;
15724 
15725  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
15726  SWIG_fail;
15727  }
15728  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15729  if (!SWIG_IsOK(res1)) {
15730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
15731  }
15732  arg1 = (char *)(buf1);
15733  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
15734  if (!SWIG_IsOK(res2)) {
15735  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
15736  }
15737  arg2 = (char *)(buf2);
15738  ecode3 = SWIG_AsVal_double(args(2), &val3);
15739  if (!SWIG_IsOK(ecode3)) {
15740  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
15741  }
15742  arg3 = (PLFLT)(val3);
15743  ecode4 = SWIG_AsVal_int(args(3), &val4);
15744  if (!SWIG_IsOK(ecode4)) {
15745  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
15746  }
15747  arg4 = (PLINT)(val4);
15748  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
15749  if (!SWIG_IsOK(res5)) {
15750  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
15751  }
15752  arg5 = (char *)(buf5);
15753  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
15754  if (!SWIG_IsOK(res6)) {
15755  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
15756  }
15757  arg6 = (char *)(buf6);
15758  ecode7 = SWIG_AsVal_double(args(6), &val7);
15759  if (!SWIG_IsOK(ecode7)) {
15760  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
15761  }
15762  arg7 = (PLFLT)(val7);
15763  ecode8 = SWIG_AsVal_int(args(7), &val8);
15764  if (!SWIG_IsOK(ecode8)) {
15765  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
15766  }
15767  arg8 = (PLINT)(val8);
15768  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
15769  if (!SWIG_IsOK(res9)) {
15770  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
15771  }
15772  arg9 = (char *)(buf9);
15773  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
15774  if (!SWIG_IsOK(res10)) {
15775  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
15776  }
15777  arg10 = (char *)(buf10);
15778  ecode11 = SWIG_AsVal_double(args(10), &val11);
15779  if (!SWIG_IsOK(ecode11)) {
15780  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
15781  }
15782  arg11 = (PLFLT)(val11);
15783  ecode12 = SWIG_AsVal_int(args(11), &val12);
15784  if (!SWIG_IsOK(ecode12)) {
15785  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
15786  }
15787  arg12 = (PLINT)(val12);
15788  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);
15789  _outv = octave_value();
15790  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15791  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15792  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15793  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
15794  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
15795  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
15796  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
15797 fail:
15798  return _out;
15799 }
15800 
15801 
15802 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
15803  PLFLT arg1 ;
15804  PLFLT arg2 ;
15805  PLFLT *arg3 = (PLFLT *) 0 ;
15806  PLFLT *arg4 = (PLFLT *) 0 ;
15807  PLINT *arg5 = (PLINT *) 0 ;
15808  double val1 ;
15809  int ecode1 = 0 ;
15810  double val2 ;
15811  int ecode2 = 0 ;
15812  PLFLT temp3 ;
15813  int res3 = SWIG_TMPOBJ ;
15814  PLFLT temp4 ;
15815  int res4 = SWIG_TMPOBJ ;
15816  PLINT temp5 ;
15817  int res5 = SWIG_TMPOBJ ;
15818  octave_value_list _out;
15819  octave_value_list *_outp=&_out;
15820  octave_value _outv;
15821 
15822  arg3 = &temp3;
15823  arg4 = &temp4;
15824  arg5 = &temp5;
15825  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
15826  SWIG_fail;
15827  }
15828  ecode1 = SWIG_AsVal_double(args(0), &val1);
15829  if (!SWIG_IsOK(ecode1)) {
15830  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
15831  }
15832  arg1 = (PLFLT)(val1);
15833  ecode2 = SWIG_AsVal_double(args(1), &val2);
15834  if (!SWIG_IsOK(ecode2)) {
15835  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
15836  }
15837  arg2 = (PLFLT)(val2);
15838  plcalc_world(arg1,arg2,arg3,arg4,arg5);
15839  _outv = octave_value();
15840  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15841  if (SWIG_IsTmpObj(res3)) {
15842  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15843  } else {
15844  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15845  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15846  }
15847  if (SWIG_IsTmpObj(res4)) {
15848  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15849  } else {
15850  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15851  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15852  }
15853  if (SWIG_IsTmpObj(res5)) {
15854  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15855  } else {
15856  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15857  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15858  }
15859 fail:
15860  return _out;
15861 }
15862 
15863 
15864 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
15865  octave_value_list _out;
15866  octave_value_list *_outp=&_out;
15867  octave_value _outv;
15868 
15869  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
15870  SWIG_fail;
15871  }
15872  plclear();
15873  _outv = octave_value();
15874  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15875 fail:
15876  return _out;
15877 }
15878 
15879 
15880 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
15881  PLINT arg1 ;
15882  int val1 ;
15883  int ecode1 = 0 ;
15884  octave_value_list _out;
15885  octave_value_list *_outp=&_out;
15886  octave_value _outv;
15887 
15888  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
15889  SWIG_fail;
15890  }
15891  ecode1 = SWIG_AsVal_int(args(0), &val1);
15892  if (!SWIG_IsOK(ecode1)) {
15893  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
15894  }
15895  arg1 = (PLINT)(val1);
15896  plcol0(arg1);
15897  _outv = octave_value();
15898  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15899 fail:
15900  return _out;
15901 }
15902 
15903 
15904 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
15905  PLFLT arg1 ;
15906  double val1 ;
15907  int ecode1 = 0 ;
15908  octave_value_list _out;
15909  octave_value_list *_outp=&_out;
15910  octave_value _outv;
15911 
15912  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
15913  SWIG_fail;
15914  }
15915  ecode1 = SWIG_AsVal_double(args(0), &val1);
15916  if (!SWIG_IsOK(ecode1)) {
15917  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
15918  }
15919  arg1 = (PLFLT)(val1);
15920  plcol1(arg1);
15921  _outv = octave_value();
15922  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15923 fail:
15924  return _out;
15925 }
15926 
15927 
15928 SWIG_DEFUN( plconfigtime, _wrap_plconfigtime, _wrap_plconfigtime_texinfo ) {
15929  PLFLT arg1 ;
15930  PLFLT arg2 ;
15931  PLFLT arg3 ;
15932  PLINT arg4 ;
15933  PLBOOL arg5 ;
15934  PLINT arg6 ;
15935  PLINT arg7 ;
15936  PLINT arg8 ;
15937  PLINT arg9 ;
15938  PLINT arg10 ;
15939  PLFLT arg11 ;
15940  double val1 ;
15941  int ecode1 = 0 ;
15942  double val2 ;
15943  int ecode2 = 0 ;
15944  double val3 ;
15945  int ecode3 = 0 ;
15946  int val4 ;
15947  int ecode4 = 0 ;
15948  int val5 ;
15949  int ecode5 = 0 ;
15950  int val6 ;
15951  int ecode6 = 0 ;
15952  int val7 ;
15953  int ecode7 = 0 ;
15954  int val8 ;
15955  int ecode8 = 0 ;
15956  int val9 ;
15957  int ecode9 = 0 ;
15958  int val10 ;
15959  int ecode10 = 0 ;
15960  double val11 ;
15961  int ecode11 = 0 ;
15962  octave_value_list _out;
15963  octave_value_list *_outp=&_out;
15964  octave_value _outv;
15965 
15966  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
15967  SWIG_fail;
15968  }
15969  ecode1 = SWIG_AsVal_double(args(0), &val1);
15970  if (!SWIG_IsOK(ecode1)) {
15971  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
15972  }
15973  arg1 = (PLFLT)(val1);
15974  ecode2 = SWIG_AsVal_double(args(1), &val2);
15975  if (!SWIG_IsOK(ecode2)) {
15976  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
15977  }
15978  arg2 = (PLFLT)(val2);
15979  ecode3 = SWIG_AsVal_double(args(2), &val3);
15980  if (!SWIG_IsOK(ecode3)) {
15981  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
15982  }
15983  arg3 = (PLFLT)(val3);
15984  ecode4 = SWIG_AsVal_int(args(3), &val4);
15985  if (!SWIG_IsOK(ecode4)) {
15986  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
15987  }
15988  arg4 = (PLINT)(val4);
15989  ecode5 = SWIG_AsVal_int(args(4), &val5);
15990  if (!SWIG_IsOK(ecode5)) {
15991  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
15992  }
15993  arg5 = (PLBOOL)(val5);
15994  ecode6 = SWIG_AsVal_int(args(5), &val6);
15995  if (!SWIG_IsOK(ecode6)) {
15996  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
15997  }
15998  arg6 = (PLINT)(val6);
15999  ecode7 = SWIG_AsVal_int(args(6), &val7);
16000  if (!SWIG_IsOK(ecode7)) {
16001  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
16002  }
16003  arg7 = (PLINT)(val7);
16004  ecode8 = SWIG_AsVal_int(args(7), &val8);
16005  if (!SWIG_IsOK(ecode8)) {
16006  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
16007  }
16008  arg8 = (PLINT)(val8);
16009  ecode9 = SWIG_AsVal_int(args(8), &val9);
16010  if (!SWIG_IsOK(ecode9)) {
16011  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
16012  }
16013  arg9 = (PLINT)(val9);
16014  ecode10 = SWIG_AsVal_int(args(9), &val10);
16015  if (!SWIG_IsOK(ecode10)) {
16016  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
16017  }
16018  arg10 = (PLINT)(val10);
16019  ecode11 = SWIG_AsVal_double(args(10), &val11);
16020  if (!SWIG_IsOK(ecode11)) {
16021  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
16022  }
16023  arg11 = (PLFLT)(val11);
16024  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16025  _outv = octave_value();
16026  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16027 fail:
16028  return _out;
16029 }
16030 
16031 
16032 SWIG_DEFUN( plctime, _wrap_plctime, _wrap_plctime_texinfo ) {
16033  PLINT arg1 ;
16034  PLINT arg2 ;
16035  PLINT arg3 ;
16036  PLINT arg4 ;
16037  PLINT arg5 ;
16038  PLFLT arg6 ;
16039  PLFLT *arg7 = (PLFLT *) 0 ;
16040  int val1 ;
16041  int ecode1 = 0 ;
16042  int val2 ;
16043  int ecode2 = 0 ;
16044  int val3 ;
16045  int ecode3 = 0 ;
16046  int val4 ;
16047  int ecode4 = 0 ;
16048  int val5 ;
16049  int ecode5 = 0 ;
16050  double val6 ;
16051  int ecode6 = 0 ;
16052  PLFLT temp7 ;
16053  int res7 = SWIG_TMPOBJ ;
16054  octave_value_list _out;
16055  octave_value_list *_outp=&_out;
16056  octave_value _outv;
16057 
16058  arg7 = &temp7;
16059  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
16060  SWIG_fail;
16061  }
16062  ecode1 = SWIG_AsVal_int(args(0), &val1);
16063  if (!SWIG_IsOK(ecode1)) {
16064  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
16065  }
16066  arg1 = (PLINT)(val1);
16067  ecode2 = SWIG_AsVal_int(args(1), &val2);
16068  if (!SWIG_IsOK(ecode2)) {
16069  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
16070  }
16071  arg2 = (PLINT)(val2);
16072  ecode3 = SWIG_AsVal_int(args(2), &val3);
16073  if (!SWIG_IsOK(ecode3)) {
16074  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
16075  }
16076  arg3 = (PLINT)(val3);
16077  ecode4 = SWIG_AsVal_int(args(3), &val4);
16078  if (!SWIG_IsOK(ecode4)) {
16079  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
16080  }
16081  arg4 = (PLINT)(val4);
16082  ecode5 = SWIG_AsVal_int(args(4), &val5);
16083  if (!SWIG_IsOK(ecode5)) {
16084  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
16085  }
16086  arg5 = (PLINT)(val5);
16087  ecode6 = SWIG_AsVal_double(args(5), &val6);
16088  if (!SWIG_IsOK(ecode6)) {
16089  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
16090  }
16091  arg6 = (PLFLT)(val6);
16092  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16093  _outv = octave_value();
16094  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16095  if (SWIG_IsTmpObj(res7)) {
16096  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
16097  } else {
16098  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16099  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
16100  }
16101 fail:
16102  return _out;
16103 }
16104 
16105 
16106 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
16107  PLINT arg1 ;
16108  PLBOOL arg2 ;
16109  int val1 ;
16110  int ecode1 = 0 ;
16111  int val2 ;
16112  int ecode2 = 0 ;
16113  octave_value_list _out;
16114  octave_value_list *_outp=&_out;
16115  octave_value _outv;
16116 
16117  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
16118  SWIG_fail;
16119  }
16120  ecode1 = SWIG_AsVal_int(args(0), &val1);
16121  if (!SWIG_IsOK(ecode1)) {
16122  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
16123  }
16124  arg1 = (PLINT)(val1);
16125  ecode2 = SWIG_AsVal_int(args(1), &val2);
16126  if (!SWIG_IsOK(ecode2)) {
16127  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
16128  }
16129  arg2 = (PLBOOL)(val2);
16130  plcpstrm(arg1,arg2);
16131  _outv = octave_value();
16132  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16133 fail:
16134  return _out;
16135 }
16136 
16137 
16138 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
16139  octave_value_list _out;
16140  octave_value_list *_outp=&_out;
16141  octave_value _outv;
16142 
16143  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
16144  SWIG_fail;
16145  }
16146  plend();
16147  _outv = octave_value();
16148  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16149 fail:
16150  return _out;
16151 }
16152 
16153 
16154 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
16155  octave_value_list _out;
16156  octave_value_list *_outp=&_out;
16157  octave_value _outv;
16158 
16159  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
16160  SWIG_fail;
16161  }
16162  plend1();
16163  _outv = octave_value();
16164  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16165 fail:
16166  return _out;
16167 }
16168 
16169 
16170 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
16171  PLFLT arg1 ;
16172  PLFLT arg2 ;
16173  PLFLT arg3 ;
16174  PLFLT arg4 ;
16175  PLINT arg5 ;
16176  PLINT arg6 ;
16177  double val1 ;
16178  int ecode1 = 0 ;
16179  double val2 ;
16180  int ecode2 = 0 ;
16181  double val3 ;
16182  int ecode3 = 0 ;
16183  double val4 ;
16184  int ecode4 = 0 ;
16185  int val5 ;
16186  int ecode5 = 0 ;
16187  int val6 ;
16188  int ecode6 = 0 ;
16189  octave_value_list _out;
16190  octave_value_list *_outp=&_out;
16191  octave_value _outv;
16192 
16193  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
16194  SWIG_fail;
16195  }
16196  ecode1 = SWIG_AsVal_double(args(0), &val1);
16197  if (!SWIG_IsOK(ecode1)) {
16198  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
16199  }
16200  arg1 = (PLFLT)(val1);
16201  ecode2 = SWIG_AsVal_double(args(1), &val2);
16202  if (!SWIG_IsOK(ecode2)) {
16203  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
16204  }
16205  arg2 = (PLFLT)(val2);
16206  ecode3 = SWIG_AsVal_double(args(2), &val3);
16207  if (!SWIG_IsOK(ecode3)) {
16208  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
16209  }
16210  arg3 = (PLFLT)(val3);
16211  ecode4 = SWIG_AsVal_double(args(3), &val4);
16212  if (!SWIG_IsOK(ecode4)) {
16213  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
16214  }
16215  arg4 = (PLFLT)(val4);
16216  ecode5 = SWIG_AsVal_int(args(4), &val5);
16217  if (!SWIG_IsOK(ecode5)) {
16218  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
16219  }
16220  arg5 = (PLINT)(val5);
16221  ecode6 = SWIG_AsVal_int(args(5), &val6);
16222  if (!SWIG_IsOK(ecode6)) {
16223  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
16224  }
16225  arg6 = (PLINT)(val6);
16226  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16227  _outv = octave_value();
16228  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16229 fail:
16230  return _out;
16231 }
16232 
16233 
16234 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
16235  PLFLT arg1 ;
16236  PLFLT arg2 ;
16237  PLFLT arg3 ;
16238  PLFLT arg4 ;
16239  PLINT arg5 ;
16240  PLINT arg6 ;
16241  double val1 ;
16242  int ecode1 = 0 ;
16243  double val2 ;
16244  int ecode2 = 0 ;
16245  double val3 ;
16246  int ecode3 = 0 ;
16247  double val4 ;
16248  int ecode4 = 0 ;
16249  int val5 ;
16250  int ecode5 = 0 ;
16251  int val6 ;
16252  int ecode6 = 0 ;
16253  octave_value_list _out;
16254  octave_value_list *_outp=&_out;
16255  octave_value _outv;
16256 
16257  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
16258  SWIG_fail;
16259  }
16260  ecode1 = SWIG_AsVal_double(args(0), &val1);
16261  if (!SWIG_IsOK(ecode1)) {
16262  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
16263  }
16264  arg1 = (PLFLT)(val1);
16265  ecode2 = SWIG_AsVal_double(args(1), &val2);
16266  if (!SWIG_IsOK(ecode2)) {
16267  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
16268  }
16269  arg2 = (PLFLT)(val2);
16270  ecode3 = SWIG_AsVal_double(args(2), &val3);
16271  if (!SWIG_IsOK(ecode3)) {
16272  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
16273  }
16274  arg3 = (PLFLT)(val3);
16275  ecode4 = SWIG_AsVal_double(args(3), &val4);
16276  if (!SWIG_IsOK(ecode4)) {
16277  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
16278  }
16279  arg4 = (PLFLT)(val4);
16280  ecode5 = SWIG_AsVal_int(args(4), &val5);
16281  if (!SWIG_IsOK(ecode5)) {
16282  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
16283  }
16284  arg5 = (PLINT)(val5);
16285  ecode6 = SWIG_AsVal_int(args(5), &val6);
16286  if (!SWIG_IsOK(ecode6)) {
16287  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
16288  }
16289  arg6 = (PLINT)(val6);
16290  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
16291  _outv = octave_value();
16292  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16293 fail:
16294  return _out;
16295 }
16296 
16297 
16298 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
16299  octave_value_list _out;
16300  octave_value_list *_outp=&_out;
16301  octave_value _outv;
16302 
16303  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
16304  SWIG_fail;
16305  }
16306  pleop();
16307  _outv = octave_value();
16308  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16309 fail:
16310  return _out;
16311 }
16312 
16313 
16314 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
16315  PLINT arg1 ;
16316  PLFLT *arg2 = (PLFLT *) 0 ;
16317  PLFLT *arg3 = (PLFLT *) 0 ;
16318  PLFLT *arg4 = (PLFLT *) 0 ;
16319  Matrix temp1 ;
16320  Matrix temp3 ;
16321  Matrix temp4 ;
16322  octave_value_list _out;
16323  octave_value_list *_outp=&_out;
16324  octave_value _outv;
16325 
16326  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
16327  SWIG_fail;
16328  }
16329  {
16330  if ( _n_dims( args(0) ) > 1 )
16331  {
16332  error( "argument must be a scalar or vector" ); SWIG_fail;
16333  }
16334  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16335  temp1 = args(0).matrix_value();
16336  arg2 = &temp1( 0, 0 );
16337  }
16338  {
16339  if ( _n_dims( args(1) ) > 1 )
16340  {
16341  error( "argument must be a scalar or vector" ); SWIG_fail;
16342  }
16343  if ( _dim( args(1), 0 ) != Alen )
16344  {
16345  error( "argument vectors must be same length" ); SWIG_fail;
16346  }
16347  temp3 = args(1).matrix_value();
16348  arg3 = &temp3( 0, 0 );
16349  }
16350  {
16351  if ( _n_dims( args(2) ) > 1 )
16352  {
16353  error( "argument must be a scalar or vector" ); SWIG_fail;
16354  }
16355  if ( _dim( args(2), 0 ) != Alen )
16356  {
16357  error( "argument vectors must be same length" ); SWIG_fail;
16358  }
16359  temp4 = args(2).matrix_value();
16360  arg4 = &temp4( 0, 0 );
16361  }
16362  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16363  _outv = octave_value();
16364  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16365  {
16366 
16367  }
16368  {
16369 
16370  }
16371  {
16372 
16373  }
16374 fail:
16375  return _out;
16376 }
16377 
16378 
16379 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
16380  PLINT arg1 ;
16381  PLFLT *arg2 = (PLFLT *) 0 ;
16382  PLFLT *arg3 = (PLFLT *) 0 ;
16383  PLFLT *arg4 = (PLFLT *) 0 ;
16384  Matrix temp1 ;
16385  Matrix temp3 ;
16386  Matrix temp4 ;
16387  octave_value_list _out;
16388  octave_value_list *_outp=&_out;
16389  octave_value _outv;
16390 
16391  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
16392  SWIG_fail;
16393  }
16394  {
16395  if ( _n_dims( args(0) ) > 1 )
16396  {
16397  error( "argument must be a scalar or vector" ); SWIG_fail;
16398  }
16399  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16400  temp1 = args(0).matrix_value();
16401  arg2 = &temp1( 0, 0 );
16402  }
16403  {
16404  if ( _n_dims( args(1) ) > 1 )
16405  {
16406  error( "argument must be a scalar or vector" ); SWIG_fail;
16407  }
16408  if ( _dim( args(1), 0 ) != Alen )
16409  {
16410  error( "argument vectors must be same length" ); SWIG_fail;
16411  }
16412  temp3 = args(1).matrix_value();
16413  arg3 = &temp3( 0, 0 );
16414  }
16415  {
16416  if ( _n_dims( args(2) ) > 1 )
16417  {
16418  error( "argument must be a scalar or vector" ); SWIG_fail;
16419  }
16420  if ( _dim( args(2), 0 ) != Alen )
16421  {
16422  error( "argument vectors must be same length" ); SWIG_fail;
16423  }
16424  temp4 = args(2).matrix_value();
16425  arg4 = &temp4( 0, 0 );
16426  }
16427  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16428  _outv = octave_value();
16429  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16430  {
16431 
16432  }
16433  {
16434 
16435  }
16436  {
16437 
16438  }
16439 fail:
16440  return _out;
16441 }
16442 
16443 
16444 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
16445  octave_value_list _out;
16446  octave_value_list *_outp=&_out;
16447  octave_value _outv;
16448 
16449  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
16450  SWIG_fail;
16451  }
16452  plfamadv();
16453  _outv = octave_value();
16454  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16455 fail:
16456  return _out;
16457 }
16458 
16459 
16460 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
16461  PLINT arg1 ;
16462  PLFLT *arg2 = (PLFLT *) 0 ;
16463  PLFLT *arg3 = (PLFLT *) 0 ;
16464  Matrix temp1 ;
16465  Matrix temp3 ;
16466  octave_value_list _out;
16467  octave_value_list *_outp=&_out;
16468  octave_value _outv;
16469 
16470  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
16471  SWIG_fail;
16472  }
16473  {
16474  if ( _n_dims( args(0) ) > 1 )
16475  {
16476  error( "argument must be a scalar or vector" ); SWIG_fail;
16477  }
16478  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16479  temp1 = args(0).matrix_value();
16480  arg2 = &temp1( 0, 0 );
16481  }
16482  {
16483  if ( _n_dims( args(1) ) > 1 )
16484  {
16485  error( "argument must be a scalar or vector" ); SWIG_fail;
16486  }
16487  if ( _dim( args(1), 0 ) != Alen )
16488  {
16489  error( "argument vectors must be same length" ); SWIG_fail;
16490  }
16491  temp3 = args(1).matrix_value();
16492  arg3 = &temp3( 0, 0 );
16493  }
16494  plfill(arg1,(double const *)arg2,(double const *)arg3);
16495  _outv = octave_value();
16496  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16497  {
16498 
16499  }
16500  {
16501 
16502  }
16503 fail:
16504  return _out;
16505 }
16506 
16507 
16508 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
16509  PLINT arg1 ;
16510  PLFLT *arg2 = (PLFLT *) 0 ;
16511  PLFLT *arg3 = (PLFLT *) 0 ;
16512  PLFLT *arg4 = (PLFLT *) 0 ;
16513  Matrix temp1 ;
16514  Matrix temp3 ;
16515  Matrix temp4 ;
16516  octave_value_list _out;
16517  octave_value_list *_outp=&_out;
16518  octave_value _outv;
16519 
16520  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
16521  SWIG_fail;
16522  }
16523  {
16524  if ( _n_dims( args(0) ) > 1 )
16525  {
16526  error( "argument must be a scalar or vector" ); SWIG_fail;
16527  }
16528  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16529  temp1 = args(0).matrix_value();
16530  arg2 = &temp1( 0, 0 );
16531  }
16532  {
16533  if ( _n_dims( args(1) ) > 1 )
16534  {
16535  error( "argument must be a scalar or vector" ); SWIG_fail;
16536  }
16537  if ( _dim( args(1), 0 ) != Alen )
16538  {
16539  error( "argument vectors must be same length" ); SWIG_fail;
16540  }
16541  temp3 = args(1).matrix_value();
16542  arg3 = &temp3( 0, 0 );
16543  }
16544  {
16545  if ( _n_dims( args(2) ) > 1 )
16546  {
16547  error( "argument must be a scalar or vector" ); SWIG_fail;
16548  }
16549  if ( _dim( args(2), 0 ) != Alen )
16550  {
16551  error( "argument vectors must be same length" ); SWIG_fail;
16552  }
16553  temp4 = args(2).matrix_value();
16554  arg4 = &temp4( 0, 0 );
16555  }
16556  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16557  _outv = octave_value();
16558  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16559  {
16560 
16561  }
16562  {
16563 
16564  }
16565  {
16566 
16567  }
16568 fail:
16569  return _out;
16570 }
16571 
16572 
16573 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
16574  PLINT arg1 ;
16575  PLFLT *arg2 = (PLFLT *) 0 ;
16576  PLFLT *arg3 = (PLFLT *) 0 ;
16577  PLFLT arg4 ;
16578  Matrix temp1 ;
16579  Matrix temp3 ;
16580  double val4 ;
16581  int ecode4 = 0 ;
16582  octave_value_list _out;
16583  octave_value_list *_outp=&_out;
16584  octave_value _outv;
16585 
16586  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
16587  SWIG_fail;
16588  }
16589  {
16590  if ( _n_dims( args(0) ) > 1 )
16591  {
16592  error( "argument must be a scalar or vector" ); SWIG_fail;
16593  }
16594  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16595  temp1 = args(0).matrix_value();
16596  arg2 = &temp1( 0, 0 );
16597  }
16598  {
16599  if ( _n_dims( args(1) ) > 1 )
16600  {
16601  error( "argument must be a scalar or vector" ); SWIG_fail;
16602  }
16603  if ( _dim( args(1), 0 ) != Alen )
16604  {
16605  error( "argument vectors must be same length" ); SWIG_fail;
16606  }
16607  temp3 = args(1).matrix_value();
16608  arg3 = &temp3( 0, 0 );
16609  }
16610  ecode4 = SWIG_AsVal_double(args(2), &val4);
16611  if (!SWIG_IsOK(ecode4)) {
16612  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
16613  }
16614  arg4 = (PLFLT)(val4);
16615  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
16616  _outv = octave_value();
16617  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16618  {
16619 
16620  }
16621  {
16622 
16623  }
16624 fail:
16625  return _out;
16626 }
16627 
16628 
16629 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
16630  octave_value_list _out;
16631  octave_value_list *_outp=&_out;
16632  octave_value _outv;
16633 
16634  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
16635  SWIG_fail;
16636  }
16637  plflush();
16638  _outv = octave_value();
16639  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16640 fail:
16641  return _out;
16642 }
16643 
16644 
16645 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
16646  PLINT arg1 ;
16647  int val1 ;
16648  int ecode1 = 0 ;
16649  octave_value_list _out;
16650  octave_value_list *_outp=&_out;
16651  octave_value _outv;
16652 
16653  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
16654  SWIG_fail;
16655  }
16656  ecode1 = SWIG_AsVal_int(args(0), &val1);
16657  if (!SWIG_IsOK(ecode1)) {
16658  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
16659  }
16660  arg1 = (PLINT)(val1);
16661  plfont(arg1);
16662  _outv = octave_value();
16663  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16664 fail:
16665  return _out;
16666 }
16667 
16668 
16669 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
16670  PLINT arg1 ;
16671  int val1 ;
16672  int ecode1 = 0 ;
16673  octave_value_list _out;
16674  octave_value_list *_outp=&_out;
16675  octave_value _outv;
16676 
16677  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
16678  SWIG_fail;
16679  }
16680  ecode1 = SWIG_AsVal_int(args(0), &val1);
16681  if (!SWIG_IsOK(ecode1)) {
16682  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
16683  }
16684  arg1 = (PLINT)(val1);
16685  plfontld(arg1);
16686  _outv = octave_value();
16687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16688 fail:
16689  return _out;
16690 }
16691 
16692 
16693 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
16694  PLFLT *arg1 = (PLFLT *) 0 ;
16695  PLFLT *arg2 = (PLFLT *) 0 ;
16696  PLFLT temp1 ;
16697  int res1 = SWIG_TMPOBJ ;
16698  PLFLT temp2 ;
16699  int res2 = SWIG_TMPOBJ ;
16700  octave_value_list _out;
16701  octave_value_list *_outp=&_out;
16702  octave_value _outv;
16703 
16704  arg1 = &temp1;
16705  arg2 = &temp2;
16706  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
16707  SWIG_fail;
16708  }
16709  plgchr(arg1,arg2);
16710  _outv = octave_value();
16711  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16712  if (SWIG_IsTmpObj(res1)) {
16713  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16714  } else {
16715  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16716  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16717  }
16718  if (SWIG_IsTmpObj(res2)) {
16719  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16720  } else {
16721  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16722  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16723  }
16724 fail:
16725  return _out;
16726 }
16727 
16728 
16729 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
16730  PLINT arg1 ;
16731  PLINT *arg2 = (PLINT *) 0 ;
16732  PLINT *arg3 = (PLINT *) 0 ;
16733  PLINT *arg4 = (PLINT *) 0 ;
16734  int val1 ;
16735  int ecode1 = 0 ;
16736  PLINT temp2 ;
16737  int res2 = SWIG_TMPOBJ ;
16738  PLINT temp3 ;
16739  int res3 = SWIG_TMPOBJ ;
16740  PLINT temp4 ;
16741  int res4 = SWIG_TMPOBJ ;
16742  octave_value_list _out;
16743  octave_value_list *_outp=&_out;
16744  octave_value _outv;
16745 
16746  arg2 = &temp2;
16747  arg3 = &temp3;
16748  arg4 = &temp4;
16749  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
16750  SWIG_fail;
16751  }
16752  ecode1 = SWIG_AsVal_int(args(0), &val1);
16753  if (!SWIG_IsOK(ecode1)) {
16754  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
16755  }
16756  arg1 = (PLINT)(val1);
16757  plgcol0(arg1,arg2,arg3,arg4);
16758  _outv = octave_value();
16759  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16760  if (SWIG_IsTmpObj(res2)) {
16761  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16762  } else {
16763  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16764  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16765  }
16766  if (SWIG_IsTmpObj(res3)) {
16767  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16768  } else {
16769  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16770  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16771  }
16772  if (SWIG_IsTmpObj(res4)) {
16773  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16774  } else {
16775  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16776  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16777  }
16778 fail:
16779  return _out;
16780 }
16781 
16782 
16783 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
16784  PLINT arg1 ;
16785  PLINT *arg2 = (PLINT *) 0 ;
16786  PLINT *arg3 = (PLINT *) 0 ;
16787  PLINT *arg4 = (PLINT *) 0 ;
16788  PLFLT *arg5 = (PLFLT *) 0 ;
16789  int val1 ;
16790  int ecode1 = 0 ;
16791  PLINT temp2 ;
16792  int res2 = SWIG_TMPOBJ ;
16793  PLINT temp3 ;
16794  int res3 = SWIG_TMPOBJ ;
16795  PLINT temp4 ;
16796  int res4 = SWIG_TMPOBJ ;
16797  PLFLT temp5 ;
16798  int res5 = SWIG_TMPOBJ ;
16799  octave_value_list _out;
16800  octave_value_list *_outp=&_out;
16801  octave_value _outv;
16802 
16803  arg2 = &temp2;
16804  arg3 = &temp3;
16805  arg4 = &temp4;
16806  arg5 = &temp5;
16807  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
16808  SWIG_fail;
16809  }
16810  ecode1 = SWIG_AsVal_int(args(0), &val1);
16811  if (!SWIG_IsOK(ecode1)) {
16812  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
16813  }
16814  arg1 = (PLINT)(val1);
16815  plgcol0a(arg1,arg2,arg3,arg4,arg5);
16816  _outv = octave_value();
16817  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16818  if (SWIG_IsTmpObj(res2)) {
16819  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16820  } else {
16821  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16822  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16823  }
16824  if (SWIG_IsTmpObj(res3)) {
16825  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16826  } else {
16827  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16828  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16829  }
16830  if (SWIG_IsTmpObj(res4)) {
16831  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16832  } else {
16833  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16834  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16835  }
16836  if (SWIG_IsTmpObj(res5)) {
16837  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
16838  } else {
16839  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16840  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
16841  }
16842 fail:
16843  return _out;
16844 }
16845 
16846 
16847 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
16848  PLINT *arg1 = (PLINT *) 0 ;
16849  PLINT *arg2 = (PLINT *) 0 ;
16850  PLINT *arg3 = (PLINT *) 0 ;
16851  PLINT temp1 ;
16852  int res1 = SWIG_TMPOBJ ;
16853  PLINT temp2 ;
16854  int res2 = SWIG_TMPOBJ ;
16855  PLINT temp3 ;
16856  int res3 = SWIG_TMPOBJ ;
16857  octave_value_list _out;
16858  octave_value_list *_outp=&_out;
16859  octave_value _outv;
16860 
16861  arg1 = &temp1;
16862  arg2 = &temp2;
16863  arg3 = &temp3;
16864  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
16865  SWIG_fail;
16866  }
16867  plgcolbg(arg1,arg2,arg3);
16868  _outv = octave_value();
16869  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16870  if (SWIG_IsTmpObj(res1)) {
16871  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16872  } else {
16873  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16874  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16875  }
16876  if (SWIG_IsTmpObj(res2)) {
16877  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16878  } else {
16879  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16880  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16881  }
16882  if (SWIG_IsTmpObj(res3)) {
16883  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16884  } else {
16885  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16886  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16887  }
16888 fail:
16889  return _out;
16890 }
16891 
16892 
16893 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
16894  PLINT *arg1 = (PLINT *) 0 ;
16895  PLINT *arg2 = (PLINT *) 0 ;
16896  PLINT *arg3 = (PLINT *) 0 ;
16897  PLFLT *arg4 = (PLFLT *) 0 ;
16898  PLINT temp1 ;
16899  int res1 = SWIG_TMPOBJ ;
16900  PLINT temp2 ;
16901  int res2 = SWIG_TMPOBJ ;
16902  PLINT temp3 ;
16903  int res3 = SWIG_TMPOBJ ;
16904  PLFLT temp4 ;
16905  int res4 = SWIG_TMPOBJ ;
16906  octave_value_list _out;
16907  octave_value_list *_outp=&_out;
16908  octave_value _outv;
16909 
16910  arg1 = &temp1;
16911  arg2 = &temp2;
16912  arg3 = &temp3;
16913  arg4 = &temp4;
16914  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
16915  SWIG_fail;
16916  }
16917  plgcolbga(arg1,arg2,arg3,arg4);
16918  _outv = octave_value();
16919  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16920  if (SWIG_IsTmpObj(res1)) {
16921  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16922  } else {
16923  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16924  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16925  }
16926  if (SWIG_IsTmpObj(res2)) {
16927  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16928  } else {
16929  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16930  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16931  }
16932  if (SWIG_IsTmpObj(res3)) {
16933  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16934  } else {
16935  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16936  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16937  }
16938  if (SWIG_IsTmpObj(res4)) {
16939  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16940  } else {
16941  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16942  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16943  }
16944 fail:
16945  return _out;
16946 }
16947 
16948 
16949 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
16950  PLINT *arg1 = (PLINT *) 0 ;
16951  PLINT temp1 ;
16952  int res1 = SWIG_TMPOBJ ;
16953  octave_value_list _out;
16954  octave_value_list *_outp=&_out;
16955  octave_value _outv;
16956 
16957  arg1 = &temp1;
16958  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
16959  SWIG_fail;
16960  }
16961  plgcompression(arg1);
16962  _outv = octave_value();
16963  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16964  if (SWIG_IsTmpObj(res1)) {
16965  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16966  } else {
16967  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16968  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16969  }
16970 fail:
16971  return _out;
16972 }
16973 
16974 
16975 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
16976  char *arg1 = (char *) 0 ;
16977  octave_value_list retval1 ;
16978  octave_value_list _out;
16979  octave_value_list *_outp=&_out;
16980  octave_value _outv;
16981 
16982  {
16983  // Check if version >= 3.4.0
16984 # if OCTAVE_API_VERSION_NUMBER < 45
16985  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
16986 # else
16987  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
16988 # endif
16989  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
16990  }
16991  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
16992  SWIG_fail;
16993  }
16994  plgdev(arg1);
16995  _outv = octave_value();
16996  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16997  {
16998  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
16999  }
17000 fail:
17001  return _out;
17002 }
17003 
17004 
17005 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
17006  PLFLT *arg1 = (PLFLT *) 0 ;
17007  PLFLT *arg2 = (PLFLT *) 0 ;
17008  PLFLT *arg3 = (PLFLT *) 0 ;
17009  PLFLT *arg4 = (PLFLT *) 0 ;
17010  PLFLT temp1 ;
17011  int res1 = SWIG_TMPOBJ ;
17012  PLFLT temp2 ;
17013  int res2 = SWIG_TMPOBJ ;
17014  PLFLT temp3 ;
17015  int res3 = SWIG_TMPOBJ ;
17016  PLFLT temp4 ;
17017  int res4 = SWIG_TMPOBJ ;
17018  octave_value_list _out;
17019  octave_value_list *_outp=&_out;
17020  octave_value _outv;
17021 
17022  arg1 = &temp1;
17023  arg2 = &temp2;
17024  arg3 = &temp3;
17025  arg4 = &temp4;
17026  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
17027  SWIG_fail;
17028  }
17029  plgdidev(arg1,arg2,arg3,arg4);
17030  _outv = octave_value();
17031  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17032  if (SWIG_IsTmpObj(res1)) {
17033  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17034  } else {
17035  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17036  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17037  }
17038  if (SWIG_IsTmpObj(res2)) {
17039  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17040  } else {
17041  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17042  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17043  }
17044  if (SWIG_IsTmpObj(res3)) {
17045  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17046  } else {
17047  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17048  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17049  }
17050  if (SWIG_IsTmpObj(res4)) {
17051  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17052  } else {
17053  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17054  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17055  }
17056 fail:
17057  return _out;
17058 }
17059 
17060 
17061 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
17062  PLFLT *arg1 = (PLFLT *) 0 ;
17063  PLFLT temp1 ;
17064  int res1 = SWIG_TMPOBJ ;
17065  octave_value_list _out;
17066  octave_value_list *_outp=&_out;
17067  octave_value _outv;
17068 
17069  arg1 = &temp1;
17070  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
17071  SWIG_fail;
17072  }
17073  plgdiori(arg1);
17074  _outv = octave_value();
17075  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17076  if (SWIG_IsTmpObj(res1)) {
17077  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17078  } else {
17079  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17080  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17081  }
17082 fail:
17083  return _out;
17084 }
17085 
17086 
17087 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
17088  PLFLT *arg1 = (PLFLT *) 0 ;
17089  PLFLT *arg2 = (PLFLT *) 0 ;
17090  PLFLT *arg3 = (PLFLT *) 0 ;
17091  PLFLT *arg4 = (PLFLT *) 0 ;
17092  PLFLT temp1 ;
17093  int res1 = SWIG_TMPOBJ ;
17094  PLFLT temp2 ;
17095  int res2 = SWIG_TMPOBJ ;
17096  PLFLT temp3 ;
17097  int res3 = SWIG_TMPOBJ ;
17098  PLFLT temp4 ;
17099  int res4 = SWIG_TMPOBJ ;
17100  octave_value_list _out;
17101  octave_value_list *_outp=&_out;
17102  octave_value _outv;
17103 
17104  arg1 = &temp1;
17105  arg2 = &temp2;
17106  arg3 = &temp3;
17107  arg4 = &temp4;
17108  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
17109  SWIG_fail;
17110  }
17111  plgdiplt(arg1,arg2,arg3,arg4);
17112  _outv = octave_value();
17113  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17114  if (SWIG_IsTmpObj(res1)) {
17115  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17116  } else {
17117  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17118  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17119  }
17120  if (SWIG_IsTmpObj(res2)) {
17121  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17122  } else {
17123  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17124  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17125  }
17126  if (SWIG_IsTmpObj(res3)) {
17127  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17128  } else {
17129  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17130  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17131  }
17132  if (SWIG_IsTmpObj(res4)) {
17133  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17134  } else {
17135  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17136  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17137  }
17138 fail:
17139  return _out;
17140 }
17141 
17142 
17143 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
17144  PLINT *arg1 = (PLINT *) 0 ;
17145  PLINT *arg2 = (PLINT *) 0 ;
17146  PLINT *arg3 = (PLINT *) 0 ;
17147  PLINT temp1 ;
17148  int res1 = SWIG_TMPOBJ ;
17149  PLINT temp2 ;
17150  int res2 = SWIG_TMPOBJ ;
17151  PLINT temp3 ;
17152  int res3 = SWIG_TMPOBJ ;
17153  octave_value_list _out;
17154  octave_value_list *_outp=&_out;
17155  octave_value _outv;
17156 
17157  arg1 = &temp1;
17158  arg2 = &temp2;
17159  arg3 = &temp3;
17160  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
17161  SWIG_fail;
17162  }
17163  plgfam(arg1,arg2,arg3);
17164  _outv = octave_value();
17165  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17166  if (SWIG_IsTmpObj(res1)) {
17167  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17168  } else {
17169  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17170  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17171  }
17172  if (SWIG_IsTmpObj(res2)) {
17173  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17174  } else {
17175  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17176  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17177  }
17178  if (SWIG_IsTmpObj(res3)) {
17179  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17180  } else {
17181  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17182  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17183  }
17184 fail:
17185  return _out;
17186 }
17187 
17188 
17189 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
17190  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
17191  PLUNICODE temp1 ;
17192  int res1 = SWIG_TMPOBJ ;
17193  octave_value_list _out;
17194  octave_value_list *_outp=&_out;
17195  octave_value _outv;
17196 
17197  arg1 = &temp1;
17198  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
17199  SWIG_fail;
17200  }
17201  plgfci(arg1);
17202  _outv = octave_value();
17203  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17204  if (SWIG_IsTmpObj(res1)) {
17205  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
17206  } else {
17207  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17208  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
17209  }
17210 fail:
17211  return _out;
17212 }
17213 
17214 
17215 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
17216  char *arg1 = (char *) 0 ;
17217  octave_value_list retval1 ;
17218  octave_value_list _out;
17219  octave_value_list *_outp=&_out;
17220  octave_value _outv;
17221 
17222  {
17223  // Check if version >= 3.4.0
17224 # if OCTAVE_API_VERSION_NUMBER < 45
17225  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17226 # else
17227  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17228 # endif
17229  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17230  }
17231  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
17232  SWIG_fail;
17233  }
17234  plgfnam(arg1);
17235  _outv = octave_value();
17236  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17237  {
17238  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17239  }
17240 fail:
17241  return _out;
17242 }
17243 
17244 
17245 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
17246  PLINT *arg1 = (PLINT *) 0 ;
17247  PLINT *arg2 = (PLINT *) 0 ;
17248  PLINT *arg3 = (PLINT *) 0 ;
17249  PLINT temp1 ;
17250  int res1 = SWIG_TMPOBJ ;
17251  PLINT temp2 ;
17252  int res2 = SWIG_TMPOBJ ;
17253  PLINT temp3 ;
17254  int res3 = SWIG_TMPOBJ ;
17255  octave_value_list _out;
17256  octave_value_list *_outp=&_out;
17257  octave_value _outv;
17258 
17259  arg1 = &temp1;
17260  arg2 = &temp2;
17261  arg3 = &temp3;
17262  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
17263  SWIG_fail;
17264  }
17265  plgfont(arg1,arg2,arg3);
17266  _outv = octave_value();
17267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17268  if (SWIG_IsTmpObj(res1)) {
17269  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17270  } else {
17271  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17272  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17273  }
17274  if (SWIG_IsTmpObj(res2)) {
17275  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17276  } else {
17277  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17278  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17279  }
17280  if (SWIG_IsTmpObj(res3)) {
17281  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17282  } else {
17283  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17284  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17285  }
17286 fail:
17287  return _out;
17288 }
17289 
17290 
17291 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
17292  PLINT *arg1 = (PLINT *) 0 ;
17293  PLINT temp1 ;
17294  int res1 = SWIG_TMPOBJ ;
17295  octave_value_list _out;
17296  octave_value_list *_outp=&_out;
17297  octave_value _outv;
17298 
17299  arg1 = &temp1;
17300  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
17301  SWIG_fail;
17302  }
17303  plglevel(arg1);
17304  _outv = octave_value();
17305  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17306  if (SWIG_IsTmpObj(res1)) {
17307  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17308  } else {
17309  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17310  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17311  }
17312 fail:
17313  return _out;
17314 }
17315 
17316 
17317 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
17318  PLFLT *arg1 = (PLFLT *) 0 ;
17319  PLFLT *arg2 = (PLFLT *) 0 ;
17320  PLINT *arg3 = (PLINT *) 0 ;
17321  PLINT *arg4 = (PLINT *) 0 ;
17322  PLINT *arg5 = (PLINT *) 0 ;
17323  PLINT *arg6 = (PLINT *) 0 ;
17324  PLFLT temp1 ;
17325  int res1 = SWIG_TMPOBJ ;
17326  PLFLT temp2 ;
17327  int res2 = SWIG_TMPOBJ ;
17328  PLINT temp3 ;
17329  int res3 = SWIG_TMPOBJ ;
17330  PLINT temp4 ;
17331  int res4 = SWIG_TMPOBJ ;
17332  PLINT temp5 ;
17333  int res5 = SWIG_TMPOBJ ;
17334  PLINT temp6 ;
17335  int res6 = SWIG_TMPOBJ ;
17336  octave_value_list _out;
17337  octave_value_list *_outp=&_out;
17338  octave_value _outv;
17339 
17340  arg1 = &temp1;
17341  arg2 = &temp2;
17342  arg3 = &temp3;
17343  arg4 = &temp4;
17344  arg5 = &temp5;
17345  arg6 = &temp6;
17346  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
17347  SWIG_fail;
17348  }
17349  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
17350  _outv = octave_value();
17351  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17352  if (SWIG_IsTmpObj(res1)) {
17353  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17354  } else {
17355  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17356  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17357  }
17358  if (SWIG_IsTmpObj(res2)) {
17359  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17360  } else {
17361  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17362  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17363  }
17364  if (SWIG_IsTmpObj(res3)) {
17365  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17366  } else {
17367  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17368  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17369  }
17370  if (SWIG_IsTmpObj(res4)) {
17371  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17372  } else {
17373  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17374  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17375  }
17376  if (SWIG_IsTmpObj(res5)) {
17377  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17378  } else {
17379  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17380  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17381  }
17382  if (SWIG_IsTmpObj(res6)) {
17383  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
17384  } else {
17385  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17386  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
17387  }
17388 fail:
17389  return _out;
17390 }
17391 
17392 
17393 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
17394  octave_value_list _out;
17395  octave_value_list *_outp=&_out;
17396  octave_value _outv;
17397 
17398  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
17399  SWIG_fail;
17400  }
17401  plgra();
17402  _outv = octave_value();
17403  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17404 fail:
17405  return _out;
17406 }
17407 
17408 
17409 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
17410  PLFLT *arg1 = (PLFLT *) 0 ;
17411  PLFLT *arg2 = (PLFLT *) 0 ;
17412  PLFLT *arg3 = (PLFLT *) 0 ;
17413  PLFLT *arg4 = (PLFLT *) 0 ;
17414  PLFLT temp1 ;
17415  int res1 = SWIG_TMPOBJ ;
17416  PLFLT temp2 ;
17417  int res2 = SWIG_TMPOBJ ;
17418  PLFLT temp3 ;
17419  int res3 = SWIG_TMPOBJ ;
17420  PLFLT temp4 ;
17421  int res4 = SWIG_TMPOBJ ;
17422  octave_value_list _out;
17423  octave_value_list *_outp=&_out;
17424  octave_value _outv;
17425 
17426  arg1 = &temp1;
17427  arg2 = &temp2;
17428  arg3 = &temp3;
17429  arg4 = &temp4;
17430  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
17431  SWIG_fail;
17432  }
17433  plgspa(arg1,arg2,arg3,arg4);
17434  _outv = octave_value();
17435  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17436  if (SWIG_IsTmpObj(res1)) {
17437  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17438  } else {
17439  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17440  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17441  }
17442  if (SWIG_IsTmpObj(res2)) {
17443  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17444  } else {
17445  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17446  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17447  }
17448  if (SWIG_IsTmpObj(res3)) {
17449  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17450  } else {
17451  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17452  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17453  }
17454  if (SWIG_IsTmpObj(res4)) {
17455  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17456  } else {
17457  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17458  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17459  }
17460 fail:
17461  return _out;
17462 }
17463 
17464 
17465 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
17466  PLINT *arg1 = (PLINT *) 0 ;
17467  PLINT temp1 ;
17468  int res1 = SWIG_TMPOBJ ;
17469  octave_value_list _out;
17470  octave_value_list *_outp=&_out;
17471  octave_value _outv;
17472 
17473  arg1 = &temp1;
17474  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
17475  SWIG_fail;
17476  }
17477  plgstrm(arg1);
17478  _outv = octave_value();
17479  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17480  if (SWIG_IsTmpObj(res1)) {
17481  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17482  } else {
17483  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17484  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17485  }
17486 fail:
17487  return _out;
17488 }
17489 
17490 
17491 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
17492  char *arg1 = (char *) 0 ;
17493  octave_value_list retval1 ;
17494  octave_value_list _out;
17495  octave_value_list *_outp=&_out;
17496  octave_value _outv;
17497 
17498  {
17499  // Check if version >= 3.4.0
17500 # if OCTAVE_API_VERSION_NUMBER < 45
17501  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17502 # else
17503  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17504 # endif
17505  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17506  }
17507  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
17508  SWIG_fail;
17509  }
17510  plgver(arg1);
17511  _outv = octave_value();
17512  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17513  {
17514  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17515  }
17516 fail:
17517  return _out;
17518 }
17519 
17520 
17521 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
17522  PLFLT *arg1 = (PLFLT *) 0 ;
17523  PLFLT *arg2 = (PLFLT *) 0 ;
17524  PLFLT *arg3 = (PLFLT *) 0 ;
17525  PLFLT *arg4 = (PLFLT *) 0 ;
17526  PLFLT temp1 ;
17527  int res1 = SWIG_TMPOBJ ;
17528  PLFLT temp2 ;
17529  int res2 = SWIG_TMPOBJ ;
17530  PLFLT temp3 ;
17531  int res3 = SWIG_TMPOBJ ;
17532  PLFLT temp4 ;
17533  int res4 = SWIG_TMPOBJ ;
17534  octave_value_list _out;
17535  octave_value_list *_outp=&_out;
17536  octave_value _outv;
17537 
17538  arg1 = &temp1;
17539  arg2 = &temp2;
17540  arg3 = &temp3;
17541  arg4 = &temp4;
17542  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
17543  SWIG_fail;
17544  }
17545  plgvpd(arg1,arg2,arg3,arg4);
17546  _outv = octave_value();
17547  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17548  if (SWIG_IsTmpObj(res1)) {
17549  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17550  } else {
17551  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17552  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17553  }
17554  if (SWIG_IsTmpObj(res2)) {
17555  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17556  } else {
17557  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17558  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17559  }
17560  if (SWIG_IsTmpObj(res3)) {
17561  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17562  } else {
17563  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17564  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17565  }
17566  if (SWIG_IsTmpObj(res4)) {
17567  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17568  } else {
17569  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17570  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17571  }
17572 fail:
17573  return _out;
17574 }
17575 
17576 
17577 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
17578  PLFLT *arg1 = (PLFLT *) 0 ;
17579  PLFLT *arg2 = (PLFLT *) 0 ;
17580  PLFLT *arg3 = (PLFLT *) 0 ;
17581  PLFLT *arg4 = (PLFLT *) 0 ;
17582  PLFLT temp1 ;
17583  int res1 = SWIG_TMPOBJ ;
17584  PLFLT temp2 ;
17585  int res2 = SWIG_TMPOBJ ;
17586  PLFLT temp3 ;
17587  int res3 = SWIG_TMPOBJ ;
17588  PLFLT temp4 ;
17589  int res4 = SWIG_TMPOBJ ;
17590  octave_value_list _out;
17591  octave_value_list *_outp=&_out;
17592  octave_value _outv;
17593 
17594  arg1 = &temp1;
17595  arg2 = &temp2;
17596  arg3 = &temp3;
17597  arg4 = &temp4;
17598  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
17599  SWIG_fail;
17600  }
17601  plgvpw(arg1,arg2,arg3,arg4);
17602  _outv = octave_value();
17603  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17604  if (SWIG_IsTmpObj(res1)) {
17605  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17606  } else {
17607  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17608  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17609  }
17610  if (SWIG_IsTmpObj(res2)) {
17611  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17612  } else {
17613  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17614  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17615  }
17616  if (SWIG_IsTmpObj(res3)) {
17617  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17618  } else {
17619  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17620  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17621  }
17622  if (SWIG_IsTmpObj(res4)) {
17623  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17624  } else {
17625  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17626  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17627  }
17628 fail:
17629  return _out;
17630 }
17631 
17632 
17633 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
17634  PLINT *arg1 = (PLINT *) 0 ;
17635  PLINT *arg2 = (PLINT *) 0 ;
17636  PLINT temp1 ;
17637  int res1 = SWIG_TMPOBJ ;
17638  PLINT temp2 ;
17639  int res2 = SWIG_TMPOBJ ;
17640  octave_value_list _out;
17641  octave_value_list *_outp=&_out;
17642  octave_value _outv;
17643 
17644  arg1 = &temp1;
17645  arg2 = &temp2;
17646  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
17647  SWIG_fail;
17648  }
17649  plgxax(arg1,arg2);
17650  _outv = octave_value();
17651  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17652  if (SWIG_IsTmpObj(res1)) {
17653  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17654  } else {
17655  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17656  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17657  }
17658  if (SWIG_IsTmpObj(res2)) {
17659  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17660  } else {
17661  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17662  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17663  }
17664 fail:
17665  return _out;
17666 }
17667 
17668 
17669 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
17670  PLINT *arg1 = (PLINT *) 0 ;
17671  PLINT *arg2 = (PLINT *) 0 ;
17672  PLINT temp1 ;
17673  int res1 = SWIG_TMPOBJ ;
17674  PLINT temp2 ;
17675  int res2 = SWIG_TMPOBJ ;
17676  octave_value_list _out;
17677  octave_value_list *_outp=&_out;
17678  octave_value _outv;
17679 
17680  arg1 = &temp1;
17681  arg2 = &temp2;
17682  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
17683  SWIG_fail;
17684  }
17685  plgyax(arg1,arg2);
17686  _outv = octave_value();
17687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17688  if (SWIG_IsTmpObj(res1)) {
17689  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17690  } else {
17691  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17692  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17693  }
17694  if (SWIG_IsTmpObj(res2)) {
17695  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17696  } else {
17697  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17698  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17699  }
17700 fail:
17701  return _out;
17702 }
17703 
17704 
17705 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
17706  PLINT *arg1 = (PLINT *) 0 ;
17707  PLINT *arg2 = (PLINT *) 0 ;
17708  PLINT temp1 ;
17709  int res1 = SWIG_TMPOBJ ;
17710  PLINT temp2 ;
17711  int res2 = SWIG_TMPOBJ ;
17712  octave_value_list _out;
17713  octave_value_list *_outp=&_out;
17714  octave_value _outv;
17715 
17716  arg1 = &temp1;
17717  arg2 = &temp2;
17718  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
17719  SWIG_fail;
17720  }
17721  plgzax(arg1,arg2);
17722  _outv = octave_value();
17723  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17724  if (SWIG_IsTmpObj(res1)) {
17725  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17726  } else {
17727  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17728  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17729  }
17730  if (SWIG_IsTmpObj(res2)) {
17731  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17732  } else {
17733  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17734  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17735  }
17736 fail:
17737  return _out;
17738 }
17739 
17740 
17741 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
17742  PLINT arg1 ;
17743  PLFLT *arg2 = (PLFLT *) 0 ;
17744  PLFLT arg3 ;
17745  PLFLT arg4 ;
17746  PLINT arg5 ;
17747  PLINT arg6 ;
17748  Matrix temp1 ;
17749  double val3 ;
17750  int ecode3 = 0 ;
17751  double val4 ;
17752  int ecode4 = 0 ;
17753  int val5 ;
17754  int ecode5 = 0 ;
17755  int val6 ;
17756  int ecode6 = 0 ;
17757  octave_value_list _out;
17758  octave_value_list *_outp=&_out;
17759  octave_value _outv;
17760 
17761  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
17762  SWIG_fail;
17763  }
17764  {
17765  if ( _n_dims( args(0) ) > 1 )
17766  {
17767  error( "argument must be a scalar or vector" ); SWIG_fail;
17768  }
17769  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17770  temp1 = args(0).matrix_value();
17771  arg2 = &temp1( 0, 0 );
17772  }
17773  ecode3 = SWIG_AsVal_double(args(1), &val3);
17774  if (!SWIG_IsOK(ecode3)) {
17775  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
17776  }
17777  arg3 = (PLFLT)(val3);
17778  ecode4 = SWIG_AsVal_double(args(2), &val4);
17779  if (!SWIG_IsOK(ecode4)) {
17780  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
17781  }
17782  arg4 = (PLFLT)(val4);
17783  ecode5 = SWIG_AsVal_int(args(3), &val5);
17784  if (!SWIG_IsOK(ecode5)) {
17785  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
17786  }
17787  arg5 = (PLINT)(val5);
17788  ecode6 = SWIG_AsVal_int(args(4), &val6);
17789  if (!SWIG_IsOK(ecode6)) {
17790  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
17791  }
17792  arg6 = (PLINT)(val6);
17793  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
17794  _outv = octave_value();
17795  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17796  {
17797 
17798  }
17799 fail:
17800  return _out;
17801 }
17802 
17803 
17804 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
17805  PLFLT arg1 ;
17806  PLFLT arg2 ;
17807  PLFLT arg3 ;
17808  PLFLT *arg4 = (PLFLT *) 0 ;
17809  PLFLT *arg5 = (PLFLT *) 0 ;
17810  PLFLT *arg6 = (PLFLT *) 0 ;
17811  double val1 ;
17812  int ecode1 = 0 ;
17813  double val2 ;
17814  int ecode2 = 0 ;
17815  double val3 ;
17816  int ecode3 = 0 ;
17817  PLFLT temp4 ;
17818  int res4 = SWIG_TMPOBJ ;
17819  PLFLT temp5 ;
17820  int res5 = SWIG_TMPOBJ ;
17821  PLFLT temp6 ;
17822  int res6 = SWIG_TMPOBJ ;
17823  octave_value_list _out;
17824  octave_value_list *_outp=&_out;
17825  octave_value _outv;
17826 
17827  arg4 = &temp4;
17828  arg5 = &temp5;
17829  arg6 = &temp6;
17830  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
17831  SWIG_fail;
17832  }
17833  ecode1 = SWIG_AsVal_double(args(0), &val1);
17834  if (!SWIG_IsOK(ecode1)) {
17835  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
17836  }
17837  arg1 = (PLFLT)(val1);
17838  ecode2 = SWIG_AsVal_double(args(1), &val2);
17839  if (!SWIG_IsOK(ecode2)) {
17840  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
17841  }
17842  arg2 = (PLFLT)(val2);
17843  ecode3 = SWIG_AsVal_double(args(2), &val3);
17844  if (!SWIG_IsOK(ecode3)) {
17845  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
17846  }
17847  arg3 = (PLFLT)(val3);
17848  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
17849  _outv = octave_value();
17850  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17851  if (SWIG_IsTmpObj(res4)) {
17852  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17853  } else {
17854  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17855  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17856  }
17857  if (SWIG_IsTmpObj(res5)) {
17858  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17859  } else {
17860  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17861  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17862  }
17863  if (SWIG_IsTmpObj(res6)) {
17864  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17865  } else {
17866  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17867  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17868  }
17869 fail:
17870  return _out;
17871 }
17872 
17873 
17874 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
17875  octave_value_list _out;
17876  octave_value_list *_outp=&_out;
17877  octave_value _outv;
17878 
17879  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
17880  SWIG_fail;
17881  }
17882  plinit();
17883  _outv = octave_value();
17884  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17885 fail:
17886  return _out;
17887 }
17888 
17889 
17890 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
17891  PLFLT arg1 ;
17892  PLFLT arg2 ;
17893  PLFLT arg3 ;
17894  PLFLT arg4 ;
17895  double val1 ;
17896  int ecode1 = 0 ;
17897  double val2 ;
17898  int ecode2 = 0 ;
17899  double val3 ;
17900  int ecode3 = 0 ;
17901  double val4 ;
17902  int ecode4 = 0 ;
17903  octave_value_list _out;
17904  octave_value_list *_outp=&_out;
17905  octave_value _outv;
17906 
17907  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
17908  SWIG_fail;
17909  }
17910  ecode1 = SWIG_AsVal_double(args(0), &val1);
17911  if (!SWIG_IsOK(ecode1)) {
17912  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
17913  }
17914  arg1 = (PLFLT)(val1);
17915  ecode2 = SWIG_AsVal_double(args(1), &val2);
17916  if (!SWIG_IsOK(ecode2)) {
17917  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
17918  }
17919  arg2 = (PLFLT)(val2);
17920  ecode3 = SWIG_AsVal_double(args(2), &val3);
17921  if (!SWIG_IsOK(ecode3)) {
17922  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
17923  }
17924  arg3 = (PLFLT)(val3);
17925  ecode4 = SWIG_AsVal_double(args(3), &val4);
17926  if (!SWIG_IsOK(ecode4)) {
17927  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
17928  }
17929  arg4 = (PLFLT)(val4);
17930  pljoin(arg1,arg2,arg3,arg4);
17931  _outv = octave_value();
17932  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17933 fail:
17934  return _out;
17935 }
17936 
17937 
17938 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
17939  char *arg1 = (char *) 0 ;
17940  char *arg2 = (char *) 0 ;
17941  char *arg3 = (char *) 0 ;
17942  int res1 ;
17943  char *buf1 = 0 ;
17944  int alloc1 = 0 ;
17945  int res2 ;
17946  char *buf2 = 0 ;
17947  int alloc2 = 0 ;
17948  int res3 ;
17949  char *buf3 = 0 ;
17950  int alloc3 = 0 ;
17951  octave_value_list _out;
17952  octave_value_list *_outp=&_out;
17953  octave_value _outv;
17954 
17955  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
17956  SWIG_fail;
17957  }
17958  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17959  if (!SWIG_IsOK(res1)) {
17960  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
17961  }
17962  arg1 = (char *)(buf1);
17963  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17964  if (!SWIG_IsOK(res2)) {
17965  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
17966  }
17967  arg2 = (char *)(buf2);
17968  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17969  if (!SWIG_IsOK(res3)) {
17970  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
17971  }
17972  arg3 = (char *)(buf3);
17973  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
17974  _outv = octave_value();
17975  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17976  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17977  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17978  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17979 fail:
17980  return _out;
17981 }
17982 
17983 
17984 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
17985  PLFLT *arg1 = (PLFLT *) 0 ;
17986  PLFLT *arg2 = (PLFLT *) 0 ;
17987  PLINT arg3 ;
17988  PLINT arg4 ;
17989  PLFLT arg5 ;
17990  PLFLT arg6 ;
17991  PLFLT arg7 ;
17992  PLINT arg8 ;
17993  PLINT arg9 ;
17994  PLINT arg10 ;
17995  PLINT arg11 ;
17996  PLINT arg12 ;
17997  PLINT arg13 ;
17998  PLINT *arg14 = (PLINT *) 0 ;
17999  PLFLT arg15 ;
18000  PLFLT arg16 ;
18001  PLFLT arg17 ;
18002  PLFLT arg18 ;
18003  PLINT *arg19 = (PLINT *) 0 ;
18004  char **arg20 = (char **) 0 ;
18005  PLINT *arg21 = (PLINT *) 0 ;
18006  PLINT *arg22 = (PLINT *) 0 ;
18007  PLFLT *arg23 = (PLFLT *) 0 ;
18008  PLFLT *arg24 = (PLFLT *) 0 ;
18009  PLINT *arg25 = (PLINT *) 0 ;
18010  PLINT *arg26 = (PLINT *) 0 ;
18011  PLFLT *arg27 = (PLFLT *) 0 ;
18012  PLINT *arg28 = (PLINT *) 0 ;
18013  PLFLT *arg29 = (PLFLT *) 0 ;
18014  PLINT *arg30 = (PLINT *) 0 ;
18015  char **arg31 = (char **) 0 ;
18016  PLFLT temp1 ;
18017  int res1 = SWIG_TMPOBJ ;
18018  PLFLT temp2 ;
18019  int res2 = SWIG_TMPOBJ ;
18020  int val3 ;
18021  int ecode3 = 0 ;
18022  int val4 ;
18023  int ecode4 = 0 ;
18024  double val5 ;
18025  int ecode5 = 0 ;
18026  double val6 ;
18027  int ecode6 = 0 ;
18028  double val7 ;
18029  int ecode7 = 0 ;
18030  int val8 ;
18031  int ecode8 = 0 ;
18032  int val9 ;
18033  int ecode9 = 0 ;
18034  int val10 ;
18035  int ecode10 = 0 ;
18036  int val11 ;
18037  int ecode11 = 0 ;
18038  int val12 ;
18039  int ecode12 = 0 ;
18040  Matrix temp13 ;
18041  double val15 ;
18042  int ecode15 = 0 ;
18043  double val16 ;
18044  int ecode16 = 0 ;
18045  double val17 ;
18046  int ecode17 = 0 ;
18047  double val18 ;
18048  int ecode18 = 0 ;
18049  Matrix temp19 ;
18050  Matrix temp21 ;
18051  Matrix temp22 ;
18052  Matrix temp23 ;
18053  Matrix temp24 ;
18054  Matrix temp25 ;
18055  Matrix temp26 ;
18056  Matrix temp27 ;
18057  Matrix temp28 ;
18058  Matrix temp29 ;
18059  Matrix temp30 ;
18060  octave_value_list _out;
18061  octave_value_list *_outp=&_out;
18062  octave_value _outv;
18063 
18064  arg1 = &temp1;
18065  arg2 = &temp2;
18066  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
18067  SWIG_fail;
18068  }
18069  ecode3 = SWIG_AsVal_int(args(0), &val3);
18070  if (!SWIG_IsOK(ecode3)) {
18071  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
18072  }
18073  arg3 = (PLINT)(val3);
18074  ecode4 = SWIG_AsVal_int(args(1), &val4);
18075  if (!SWIG_IsOK(ecode4)) {
18076  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
18077  }
18078  arg4 = (PLINT)(val4);
18079  ecode5 = SWIG_AsVal_double(args(2), &val5);
18080  if (!SWIG_IsOK(ecode5)) {
18081  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
18082  }
18083  arg5 = (PLFLT)(val5);
18084  ecode6 = SWIG_AsVal_double(args(3), &val6);
18085  if (!SWIG_IsOK(ecode6)) {
18086  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
18087  }
18088  arg6 = (PLFLT)(val6);
18089  ecode7 = SWIG_AsVal_double(args(4), &val7);
18090  if (!SWIG_IsOK(ecode7)) {
18091  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
18092  }
18093  arg7 = (PLFLT)(val7);
18094  ecode8 = SWIG_AsVal_int(args(5), &val8);
18095  if (!SWIG_IsOK(ecode8)) {
18096  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
18097  }
18098  arg8 = (PLINT)(val8);
18099  ecode9 = SWIG_AsVal_int(args(6), &val9);
18100  if (!SWIG_IsOK(ecode9)) {
18101  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
18102  }
18103  arg9 = (PLINT)(val9);
18104  ecode10 = SWIG_AsVal_int(args(7), &val10);
18105  if (!SWIG_IsOK(ecode10)) {
18106  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
18107  }
18108  arg10 = (PLINT)(val10);
18109  ecode11 = SWIG_AsVal_int(args(8), &val11);
18110  if (!SWIG_IsOK(ecode11)) {
18111  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
18112  }
18113  arg11 = (PLINT)(val11);
18114  ecode12 = SWIG_AsVal_int(args(9), &val12);
18115  if (!SWIG_IsOK(ecode12)) {
18116  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
18117  }
18118  arg12 = (PLINT)(val12);
18119  {
18120  if ( _n_dims( args(10) ) > 1 )
18121  {
18122  error( "argument must be a scalar or vector" ); SWIG_fail;
18123  }
18124  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
18125  arg14 = new PLINT[Alen];
18126  temp13 = args(10).matrix_value();
18127  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
18128  }
18129  ecode15 = SWIG_AsVal_double(args(11), &val15);
18130  if (!SWIG_IsOK(ecode15)) {
18131  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
18132  }
18133  arg15 = (PLFLT)(val15);
18134  ecode16 = SWIG_AsVal_double(args(12), &val16);
18135  if (!SWIG_IsOK(ecode16)) {
18136  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
18137  }
18138  arg16 = (PLFLT)(val16);
18139  ecode17 = SWIG_AsVal_double(args(13), &val17);
18140  if (!SWIG_IsOK(ecode17)) {
18141  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
18142  }
18143  arg17 = (PLFLT)(val17);
18144  ecode18 = SWIG_AsVal_double(args(14), &val18);
18145  if (!SWIG_IsOK(ecode18)) {
18146  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
18147  }
18148  arg18 = (PLFLT)(val18);
18149  {
18150  if ( _n_dims( args(15) ) > 1 )
18151  {
18152  error( "argument must be a scalar or vector" ); SWIG_fail;
18153  }
18154  if ( _dim( args(15), 0 ) != Alen )
18155  {
18156  error( "argument vectors must be same length" ); SWIG_fail;
18157  }
18158  temp19 = args(15).matrix_value();
18159  arg19 = new PLINT[Alen];
18160  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
18161  }
18162  {
18163  charMatrix temp_matrix;
18164  Cell temp_cell;
18165  char *tmp_cstring;
18166  std::string str;
18167  size_t max_length = 0, non_blank_length;
18168  int i, ifcell;
18169  if ( _n_dims( args(16) ) > 2 )
18170  {
18171  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
18172  }
18173  if ( !args(16).is_empty() )
18174  {
18175  if ( _dim( args(16), 0 ) != Alen )
18176  {
18177  error( "first dimension must be same length as previous vector" ); SWIG_fail;
18178  }
18179  arg20 = new char*[Alen];
18180  ifcell = args(16).is_cell();
18181  if ( ifcell )
18182  {
18183  temp_cell = args(16).cell_value();
18184  }
18185  else
18186  {
18187  temp_matrix = args(16).char_matrix_value();
18188  // Allow one extra space for null termination.
18189  max_length = _dim( args(16), 1 ) + 1;
18190  }
18191 
18192  for ( i = 0; i < Alen; i++ )
18193  {
18194  // Must copy string to "permanent" location because the string
18195  // location corresponding to tmp_cstring gets
18196  // overwritten for each iteration of loop.
18197  if ( ifcell )
18198  {
18199  if ( temp_cell.elem( i ).is_string() )
18200  {
18201  str = temp_cell.elem( i ).string_value();
18202  // leave room for null termination.
18203  max_length = str.size() + 1;
18204  tmp_cstring = (char *) str.c_str();
18205  }
18206  else
18207  {
18208  // Use null string if user attempts to pass a cell array
18209  // with a non-string element (likely an empty element
18210  // since that should be allowed by the PLplot interface
18211  // if that element is going to be unused).
18212  // leave room for null termination.
18213  max_length = 1;
18214  tmp_cstring = (char *) "";
18215  }
18216  }
18217  else
18218  {
18219  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
18220  }
18221  arg20[i] = new char[max_length];
18222  strncpy( arg20[i], tmp_cstring, max_length - 1 );
18223  arg20[i][max_length - 1] = '\0';
18224  // All the trailing blank crapola should not be needed for
18225  // string cell arrays.
18226  if ( !ifcell )
18227  {
18228  // remove trailing-blank padding that is used by the
18229  // charMatrix class to insure all strings in a given
18230  // charMatrix instance have the same length.
18231  // This transformation also removes legitimate trailing
18232  // blanks but there is nothing we can do about that
18233  // for the charMatrix class.
18234 
18235  // Look for trailing nulls first (just in case, although that
18236  // shouldn't happen if charMatrix implemented as documented)
18237  // before looking for trailing blanks.
18238  non_blank_length = max_length - 2;
18239  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
18240  {
18241  non_blank_length--;
18242  }
18243  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
18244  {
18245  non_blank_length--;
18246  }
18247  arg20[i][non_blank_length + 1] = '\0';
18248  }
18249  }
18250  }
18251  else
18252  {
18253  arg20 = NULL;
18254  }
18255  }
18256  {
18257  if ( _n_dims( args(17) ) > 1 )
18258  {
18259  error( "argument must be a scalar or vector" ); SWIG_fail;
18260  }
18261  if ( !args(17).is_empty() )
18262  {
18263  if ( _dim( args(17), 0 ) != Alen )
18264  {
18265  error( "argument vectors must be same length" ); SWIG_fail;
18266  }
18267  temp21 = args(17).matrix_value();
18268  arg21 = new PLINT[Alen];
18269  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
18270  }
18271  else
18272  {
18273  arg21 = NULL;
18274  }
18275  }
18276  {
18277  if ( _n_dims( args(18) ) > 1 )
18278  {
18279  error( "argument must be a scalar or vector" ); SWIG_fail;
18280  }
18281  if ( !args(18).is_empty() )
18282  {
18283  if ( _dim( args(18), 0 ) != Alen )
18284  {
18285  error( "argument vectors must be same length" ); SWIG_fail;
18286  }
18287  temp22 = args(18).matrix_value();
18288  arg22 = new PLINT[Alen];
18289  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
18290  }
18291  else
18292  {
18293  arg22 = NULL;
18294  }
18295  }
18296  {
18297  if ( _n_dims( args(19) ) > 1 )
18298  {
18299  error( "argument must be a scalar or vector" ); SWIG_fail;
18300  }
18301  if ( !args(19).is_empty() )
18302  {
18303  if ( _dim( args(19), 0 ) != Alen )
18304  {
18305  error( "argument vectors must be same length" ); SWIG_fail;
18306  }
18307  temp23 = args(19).matrix_value();
18308  arg23 = &temp23( 0, 0 );
18309  }
18310  else
18311  {
18312  arg23 = NULL;
18313  }
18314  }
18315  {
18316  if ( _n_dims( args(20) ) > 1 )
18317  {
18318  error( "argument must be a scalar or vector" ); SWIG_fail;
18319  }
18320  if ( !args(20).is_empty() )
18321  {
18322  if ( _dim( args(20), 0 ) != Alen )
18323  {
18324  error( "argument vectors must be same length" ); SWIG_fail;
18325  }
18326  temp24 = args(20).matrix_value();
18327  arg24 = &temp24( 0, 0 );
18328  }
18329  else
18330  {
18331  arg24 = NULL;
18332  }
18333  }
18334  {
18335  if ( _n_dims( args(21) ) > 1 )
18336  {
18337  error( "argument must be a scalar or vector" ); SWIG_fail;
18338  }
18339  if ( !args(21).is_empty() )
18340  {
18341  if ( _dim( args(21), 0 ) != Alen )
18342  {
18343  error( "argument vectors must be same length" ); SWIG_fail;
18344  }
18345  temp25 = args(21).matrix_value();
18346  arg25 = new PLINT[Alen];
18347  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
18348  }
18349  else
18350  {
18351  arg25 = NULL;
18352  }
18353  }
18354  {
18355  if ( _n_dims( args(22) ) > 1 )
18356  {
18357  error( "argument must be a scalar or vector" ); SWIG_fail;
18358  }
18359  if ( !args(22).is_empty() )
18360  {
18361  if ( _dim( args(22), 0 ) != Alen )
18362  {
18363  error( "argument vectors must be same length" ); SWIG_fail;
18364  }
18365  temp26 = args(22).matrix_value();
18366  arg26 = new PLINT[Alen];
18367  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
18368  }
18369  else
18370  {
18371  arg26 = NULL;
18372  }
18373  }
18374  {
18375  if ( _n_dims( args(23) ) > 1 )
18376  {
18377  error( "argument must be a scalar or vector" ); SWIG_fail;
18378  }
18379  if ( !args(23).is_empty() )
18380  {
18381  if ( _dim( args(23), 0 ) != Alen )
18382  {
18383  error( "argument vectors must be same length" ); SWIG_fail;
18384  }
18385  temp27 = args(23).matrix_value();
18386  arg27 = &temp27( 0, 0 );
18387  }
18388  else
18389  {
18390  arg27 = NULL;
18391  }
18392  }
18393  {
18394  if ( _n_dims( args(24) ) > 1 )
18395  {
18396  error( "argument must be a scalar or vector" ); SWIG_fail;
18397  }
18398  if ( !args(24).is_empty() )
18399  {
18400  if ( _dim( args(24), 0 ) != Alen )
18401  {
18402  error( "argument vectors must be same length" ); SWIG_fail;
18403  }
18404  temp28 = args(24).matrix_value();
18405  arg28 = new PLINT[Alen];
18406  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
18407  }
18408  else
18409  {
18410  arg28 = NULL;
18411  }
18412  }
18413  {
18414  if ( _n_dims( args(25) ) > 1 )
18415  {
18416  error( "argument must be a scalar or vector" ); SWIG_fail;
18417  }
18418  if ( !args(25).is_empty() )
18419  {
18420  if ( _dim( args(25), 0 ) != Alen )
18421  {
18422  error( "argument vectors must be same length" ); SWIG_fail;
18423  }
18424  temp29 = args(25).matrix_value();
18425  arg29 = &temp29( 0, 0 );
18426  }
18427  else
18428  {
18429  arg29 = NULL;
18430  }
18431  }
18432  {
18433  if ( _n_dims( args(26) ) > 1 )
18434  {
18435  error( "argument must be a scalar or vector" ); SWIG_fail;
18436  }
18437  if ( !args(26).is_empty() )
18438  {
18439  if ( _dim( args(26), 0 ) != Alen )
18440  {
18441  error( "argument vectors must be same length" ); SWIG_fail;
18442  }
18443  temp30 = args(26).matrix_value();
18444  arg30 = new PLINT[Alen];
18445  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
18446  }
18447  else
18448  {
18449  arg30 = NULL;
18450  }
18451  }
18452  {
18453  charMatrix temp_matrix;
18454  Cell temp_cell;
18455  char *tmp_cstring;
18456  std::string str;
18457  size_t max_length = 0, non_blank_length;
18458  int i, ifcell;
18459  if ( _n_dims( args(27) ) > 2 )
18460  {
18461  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
18462  }
18463  if ( !args(27).is_empty() )
18464  {
18465  if ( _dim( args(27), 0 ) != Alen )
18466  {
18467  error( "first dimension must be same length as previous vector" ); SWIG_fail;
18468  }
18469  arg31 = new char*[Alen];
18470  ifcell = args(27).is_cell();
18471  if ( ifcell )
18472  {
18473  temp_cell = args(27).cell_value();
18474  }
18475  else
18476  {
18477  temp_matrix = args(27).char_matrix_value();
18478  // Allow one extra space for null termination.
18479  max_length = _dim( args(27), 1 ) + 1;
18480  }
18481 
18482  for ( i = 0; i < Alen; i++ )
18483  {
18484  // Must copy string to "permanent" location because the string
18485  // location corresponding to tmp_cstring gets
18486  // overwritten for each iteration of loop.
18487  if ( ifcell )
18488  {
18489  if ( temp_cell.elem( i ).is_string() )
18490  {
18491  str = temp_cell.elem( i ).string_value();
18492  // leave room for null termination.
18493  max_length = str.size() + 1;
18494  tmp_cstring = (char *) str.c_str();
18495  }
18496  else
18497  {
18498  // Use null string if user attempts to pass a cell array
18499  // with a non-string element (likely an empty element
18500  // since that should be allowed by the PLplot interface
18501  // if that element is going to be unused).
18502  // leave room for null termination.
18503  max_length = 1;
18504  tmp_cstring = (char *) "";
18505  }
18506  }
18507  else
18508  {
18509  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
18510  }
18511  arg31[i] = new char[max_length];
18512  strncpy( arg31[i], tmp_cstring, max_length - 1 );
18513  arg31[i][max_length - 1] = '\0';
18514  // All the trailing blank crapola should not be needed for
18515  // string cell arrays.
18516  if ( !ifcell )
18517  {
18518  // remove trailing-blank padding that is used by the
18519  // charMatrix class to insure all strings in a given
18520  // charMatrix instance have the same length.
18521  // This transformation also removes legitimate trailing
18522  // blanks but there is nothing we can do about that
18523  // for the charMatrix class.
18524 
18525  // Look for trailing nulls first (just in case, although that
18526  // shouldn't happen if charMatrix implemented as documented)
18527  // before looking for trailing blanks.
18528  non_blank_length = max_length - 2;
18529  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
18530  {
18531  non_blank_length--;
18532  }
18533  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
18534  {
18535  non_blank_length--;
18536  }
18537  arg31[i][non_blank_length + 1] = '\0';
18538  }
18539  }
18540  }
18541  else
18542  {
18543  arg31 = NULL;
18544  }
18545  }
18546  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);
18547  _outv = octave_value();
18548  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18549  if (SWIG_IsTmpObj(res1)) {
18550  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18551  } else {
18552  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18553  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18554  }
18555  if (SWIG_IsTmpObj(res2)) {
18556  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18557  } else {
18558  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18559  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18560  }
18561  {
18562  delete [] arg14;
18563  }
18564  {
18565  delete [] arg19;
18566  }
18567  {
18568  int i;
18569  if ( arg20 != NULL )
18570  {
18571  for ( i = 0; i < Alen; i++ )
18572  {
18573  delete[] arg20[i];
18574  }
18575  delete[] arg20;
18576  }
18577  }
18578  {
18579  if ( arg21 != NULL )
18580  delete [] arg21;
18581  }
18582  {
18583  if ( arg22 != NULL )
18584  delete [] arg22;
18585  }
18586  {
18587 
18588  }
18589  {
18590 
18591  }
18592  {
18593  if ( arg25 != NULL )
18594  delete [] arg25;
18595  }
18596  {
18597  if ( arg26 != NULL )
18598  delete [] arg26;
18599  }
18600  {
18601 
18602  }
18603  {
18604  if ( arg28 != NULL )
18605  delete [] arg28;
18606  }
18607  {
18608 
18609  }
18610  {
18611  if ( arg30 != NULL )
18612  delete [] arg30;
18613  }
18614  {
18615  int i;
18616  if ( arg31 != NULL )
18617  {
18618  for ( i = 0; i < Alen; i++ )
18619  {
18620  delete[] arg31[i];
18621  }
18622  delete[] arg31;
18623  }
18624  }
18625 fail:
18626  return _out;
18627 }
18628 
18629 
18630 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
18631  PLFLT arg1 ;
18632  PLFLT arg2 ;
18633  PLFLT arg3 ;
18634  double val1 ;
18635  int ecode1 = 0 ;
18636  double val2 ;
18637  int ecode2 = 0 ;
18638  double val3 ;
18639  int ecode3 = 0 ;
18640  octave_value_list _out;
18641  octave_value_list *_outp=&_out;
18642  octave_value _outv;
18643 
18644  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
18645  SWIG_fail;
18646  }
18647  ecode1 = SWIG_AsVal_double(args(0), &val1);
18648  if (!SWIG_IsOK(ecode1)) {
18649  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
18650  }
18651  arg1 = (PLFLT)(val1);
18652  ecode2 = SWIG_AsVal_double(args(1), &val2);
18653  if (!SWIG_IsOK(ecode2)) {
18654  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
18655  }
18656  arg2 = (PLFLT)(val2);
18657  ecode3 = SWIG_AsVal_double(args(2), &val3);
18658  if (!SWIG_IsOK(ecode3)) {
18659  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
18660  }
18661  arg3 = (PLFLT)(val3);
18662  pllightsource(arg1,arg2,arg3);
18663  _outv = octave_value();
18664  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18665 fail:
18666  return _out;
18667 }
18668 
18669 
18670 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
18671  PLINT arg1 ;
18672  PLFLT *arg2 = (PLFLT *) 0 ;
18673  PLFLT *arg3 = (PLFLT *) 0 ;
18674  Matrix temp1 ;
18675  Matrix temp3 ;
18676  octave_value_list _out;
18677  octave_value_list *_outp=&_out;
18678  octave_value _outv;
18679 
18680  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
18681  SWIG_fail;
18682  }
18683  {
18684  if ( _n_dims( args(0) ) > 1 )
18685  {
18686  error( "argument must be a scalar or vector" ); SWIG_fail;
18687  }
18688  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18689  temp1 = args(0).matrix_value();
18690  arg2 = &temp1( 0, 0 );
18691  }
18692  {
18693  if ( _n_dims( args(1) ) > 1 )
18694  {
18695  error( "argument must be a scalar or vector" ); SWIG_fail;
18696  }
18697  if ( _dim( args(1), 0 ) != Alen )
18698  {
18699  error( "argument vectors must be same length" ); SWIG_fail;
18700  }
18701  temp3 = args(1).matrix_value();
18702  arg3 = &temp3( 0, 0 );
18703  }
18704  plline(arg1,(double const *)arg2,(double const *)arg3);
18705  _outv = octave_value();
18706  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18707  {
18708 
18709  }
18710  {
18711 
18712  }
18713 fail:
18714  return _out;
18715 }
18716 
18717 
18718 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
18719  PLINT arg1 ;
18720  PLFLT *arg2 = (PLFLT *) 0 ;
18721  PLFLT *arg3 = (PLFLT *) 0 ;
18722  PLFLT *arg4 = (PLFLT *) 0 ;
18723  Matrix temp1 ;
18724  Matrix temp3 ;
18725  Matrix temp4 ;
18726  octave_value_list _out;
18727  octave_value_list *_outp=&_out;
18728  octave_value _outv;
18729 
18730  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
18731  SWIG_fail;
18732  }
18733  {
18734  if ( _n_dims( args(0) ) > 1 )
18735  {
18736  error( "argument must be a scalar or vector" ); SWIG_fail;
18737  }
18738  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18739  temp1 = args(0).matrix_value();
18740  arg2 = &temp1( 0, 0 );
18741  }
18742  {
18743  if ( _n_dims( args(1) ) > 1 )
18744  {
18745  error( "argument must be a scalar or vector" ); SWIG_fail;
18746  }
18747  if ( _dim( args(1), 0 ) != Alen )
18748  {
18749  error( "argument vectors must be same length" ); SWIG_fail;
18750  }
18751  temp3 = args(1).matrix_value();
18752  arg3 = &temp3( 0, 0 );
18753  }
18754  {
18755  if ( _n_dims( args(2) ) > 1 )
18756  {
18757  error( "argument must be a scalar or vector" ); SWIG_fail;
18758  }
18759  if ( _dim( args(2), 0 ) != Alen )
18760  {
18761  error( "argument vectors must be same length" ); SWIG_fail;
18762  }
18763  temp4 = args(2).matrix_value();
18764  arg4 = &temp4( 0, 0 );
18765  }
18766  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18767  _outv = octave_value();
18768  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18769  {
18770 
18771  }
18772  {
18773 
18774  }
18775  {
18776 
18777  }
18778 fail:
18779  return _out;
18780 }
18781 
18782 
18783 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
18784  PLINT arg1 ;
18785  int val1 ;
18786  int ecode1 = 0 ;
18787  octave_value_list _out;
18788  octave_value_list *_outp=&_out;
18789  octave_value _outv;
18790 
18791  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
18792  SWIG_fail;
18793  }
18794  ecode1 = SWIG_AsVal_int(args(0), &val1);
18795  if (!SWIG_IsOK(ecode1)) {
18796  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
18797  }
18798  arg1 = (PLINT)(val1);
18799  pllsty(arg1);
18800  _outv = octave_value();
18801  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18802 fail:
18803  return _out;
18804 }
18805 
18806 
18807 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
18808  PLINT *arg1 = (PLINT *) 0 ;
18809  PLINT temp1 ;
18810  int res1 = SWIG_TMPOBJ ;
18811  octave_value_list _out;
18812  octave_value_list *_outp=&_out;
18813  octave_value _outv;
18814 
18815  arg1 = &temp1;
18816  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
18817  SWIG_fail;
18818  }
18819  plmkstrm(arg1);
18820  _outv = octave_value();
18821  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18822  if (SWIG_IsTmpObj(res1)) {
18823  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18824  } else {
18825  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18826  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18827  }
18828 fail:
18829  return _out;
18830 }
18831 
18832 
18833 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
18834  char *arg1 = (char *) 0 ;
18835  PLFLT arg2 ;
18836  PLFLT arg3 ;
18837  PLFLT arg4 ;
18838  char *arg5 = (char *) 0 ;
18839  int res1 ;
18840  char *buf1 = 0 ;
18841  int alloc1 = 0 ;
18842  double val2 ;
18843  int ecode2 = 0 ;
18844  double val3 ;
18845  int ecode3 = 0 ;
18846  double val4 ;
18847  int ecode4 = 0 ;
18848  int res5 ;
18849  char *buf5 = 0 ;
18850  int alloc5 = 0 ;
18851  octave_value_list _out;
18852  octave_value_list *_outp=&_out;
18853  octave_value _outv;
18854 
18855  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
18856  SWIG_fail;
18857  }
18858  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18859  if (!SWIG_IsOK(res1)) {
18860  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
18861  }
18862  arg1 = (char *)(buf1);
18863  ecode2 = SWIG_AsVal_double(args(1), &val2);
18864  if (!SWIG_IsOK(ecode2)) {
18865  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
18866  }
18867  arg2 = (PLFLT)(val2);
18868  ecode3 = SWIG_AsVal_double(args(2), &val3);
18869  if (!SWIG_IsOK(ecode3)) {
18870  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
18871  }
18872  arg3 = (PLFLT)(val3);
18873  ecode4 = SWIG_AsVal_double(args(3), &val4);
18874  if (!SWIG_IsOK(ecode4)) {
18875  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
18876  }
18877  arg4 = (PLFLT)(val4);
18878  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
18879  if (!SWIG_IsOK(res5)) {
18880  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
18881  }
18882  arg5 = (char *)(buf5);
18883  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
18884  _outv = octave_value();
18885  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18886  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18887  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
18888 fail:
18889  return _out;
18890 }
18891 
18892 
18893 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
18894  char *arg1 = (char *) 0 ;
18895  PLFLT arg2 ;
18896  PLFLT arg3 ;
18897  PLFLT arg4 ;
18898  char *arg5 = (char *) 0 ;
18899  int res1 ;
18900  char *buf1 = 0 ;
18901  int alloc1 = 0 ;
18902  double val2 ;
18903  int ecode2 = 0 ;
18904  double val3 ;
18905  int ecode3 = 0 ;
18906  double val4 ;
18907  int ecode4 = 0 ;
18908  int res5 ;
18909  char *buf5 = 0 ;
18910  int alloc5 = 0 ;
18911  octave_value_list _out;
18912  octave_value_list *_outp=&_out;
18913  octave_value _outv;
18914 
18915  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
18916  SWIG_fail;
18917  }
18918  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18919  if (!SWIG_IsOK(res1)) {
18920  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
18921  }
18922  arg1 = (char *)(buf1);
18923  ecode2 = SWIG_AsVal_double(args(1), &val2);
18924  if (!SWIG_IsOK(ecode2)) {
18925  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
18926  }
18927  arg2 = (PLFLT)(val2);
18928  ecode3 = SWIG_AsVal_double(args(2), &val3);
18929  if (!SWIG_IsOK(ecode3)) {
18930  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
18931  }
18932  arg3 = (PLFLT)(val3);
18933  ecode4 = SWIG_AsVal_double(args(3), &val4);
18934  if (!SWIG_IsOK(ecode4)) {
18935  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
18936  }
18937  arg4 = (PLFLT)(val4);
18938  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
18939  if (!SWIG_IsOK(res5)) {
18940  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
18941  }
18942  arg5 = (char *)(buf5);
18943  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
18944  _outv = octave_value();
18945  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18946  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18947  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
18948 fail:
18949  return _out;
18950 }
18951 
18952 
18953 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
18954  int *arg1 = (int *) 0 ;
18955  char **arg2 = (char **) 0 ;
18956  PLINT arg3 ;
18957  void *argp1 = 0 ;
18958  int res1 = 0 ;
18959  void *argp2 = 0 ;
18960  int res2 = 0 ;
18961  int val3 ;
18962  int ecode3 = 0 ;
18963  octave_value_list _out;
18964  octave_value_list *_outp=&_out;
18965  octave_value _outv;
18966  PLINT result;
18967 
18968  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
18969  SWIG_fail;
18970  }
18971  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
18972  if (!SWIG_IsOK(res1)) {
18973  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
18974  }
18975  arg1 = (int *)(argp1);
18976  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
18977  if (!SWIG_IsOK(res2)) {
18978  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char const **""'");
18979  }
18980  arg2 = (char **)(argp2);
18981  ecode3 = SWIG_AsVal_int(args(2), &val3);
18982  if (!SWIG_IsOK(ecode3)) {
18983  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
18984  }
18985  arg3 = (PLINT)(val3);
18986  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
18987  _outv = SWIG_From_int((int)(result));
18988  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18989 fail:
18990  return _out;
18991 }
18992 
18993 
18994 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
18995  PLINT arg1 ;
18996  PLINT *arg2 = (PLINT *) 0 ;
18997  PLINT *arg3 = (PLINT *) 0 ;
18998  Matrix temp1 ;
18999  Matrix temp3 ;
19000  octave_value_list _out;
19001  octave_value_list *_outp=&_out;
19002  octave_value _outv;
19003 
19004  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
19005  SWIG_fail;
19006  }
19007  {
19008  if ( _n_dims( args(0) ) > 1 )
19009  {
19010  error( "argument must be a scalar or vector" ); SWIG_fail;
19011  }
19012  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19013  arg2 = new PLINT[Alen];
19014  temp1 = args(0).matrix_value();
19015  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
19016  }
19017  {
19018  if ( _n_dims( args(1) ) > 1 )
19019  {
19020  error( "argument must be a scalar or vector" ); SWIG_fail;
19021  }
19022  if ( _dim( args(1), 0 ) != Alen )
19023  {
19024  error( "argument vectors must be same length" ); SWIG_fail;
19025  }
19026  temp3 = args(1).matrix_value();
19027  arg3 = new PLINT[Alen];
19028  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19029  }
19030  plpat(arg1,(int const *)arg2,(int const *)arg3);
19031  _outv = octave_value();
19032  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19033  {
19034  delete [] arg2;
19035  }
19036  {
19037  delete [] arg3;
19038  }
19039 fail:
19040  return _out;
19041 }
19042 
19043 
19044 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
19045  PLINT arg1 ;
19046  PLFLT arg2 ;
19047  PLFLT arg3 ;
19048  PLFLT arg4 ;
19049  PLFLT arg5 ;
19050  int val1 ;
19051  int ecode1 = 0 ;
19052  double val2 ;
19053  int ecode2 = 0 ;
19054  double val3 ;
19055  int ecode3 = 0 ;
19056  double val4 ;
19057  int ecode4 = 0 ;
19058  double val5 ;
19059  int ecode5 = 0 ;
19060  octave_value_list _out;
19061  octave_value_list *_outp=&_out;
19062  octave_value _outv;
19063 
19064  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
19065  SWIG_fail;
19066  }
19067  ecode1 = SWIG_AsVal_int(args(0), &val1);
19068  if (!SWIG_IsOK(ecode1)) {
19069  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
19070  }
19071  arg1 = (PLINT)(val1);
19072  ecode2 = SWIG_AsVal_double(args(1), &val2);
19073  if (!SWIG_IsOK(ecode2)) {
19074  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
19075  }
19076  arg2 = (PLFLT)(val2);
19077  ecode3 = SWIG_AsVal_double(args(2), &val3);
19078  if (!SWIG_IsOK(ecode3)) {
19079  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
19080  }
19081  arg3 = (PLFLT)(val3);
19082  ecode4 = SWIG_AsVal_double(args(3), &val4);
19083  if (!SWIG_IsOK(ecode4)) {
19084  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
19085  }
19086  arg4 = (PLFLT)(val4);
19087  ecode5 = SWIG_AsVal_double(args(4), &val5);
19088  if (!SWIG_IsOK(ecode5)) {
19089  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
19090  }
19091  arg5 = (PLFLT)(val5);
19092  plpath(arg1,arg2,arg3,arg4,arg5);
19093  _outv = octave_value();
19094  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19095 fail:
19096  return _out;
19097 }
19098 
19099 
19100 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
19101  PLINT arg1 ;
19102  PLFLT *arg2 = (PLFLT *) 0 ;
19103  PLFLT *arg3 = (PLFLT *) 0 ;
19104  PLINT arg4 ;
19105  Matrix temp1 ;
19106  Matrix temp3 ;
19107  int val4 ;
19108  int ecode4 = 0 ;
19109  octave_value_list _out;
19110  octave_value_list *_outp=&_out;
19111  octave_value _outv;
19112 
19113  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
19114  SWIG_fail;
19115  }
19116  {
19117  if ( _n_dims( args(0) ) > 1 )
19118  {
19119  error( "argument must be a scalar or vector" ); SWIG_fail;
19120  }
19121  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19122  temp1 = args(0).matrix_value();
19123  arg2 = &temp1( 0, 0 );
19124  }
19125  {
19126  if ( _n_dims( args(1) ) > 1 )
19127  {
19128  error( "argument must be a scalar or vector" ); SWIG_fail;
19129  }
19130  if ( _dim( args(1), 0 ) != Alen )
19131  {
19132  error( "argument vectors must be same length" ); SWIG_fail;
19133  }
19134  temp3 = args(1).matrix_value();
19135  arg3 = &temp3( 0, 0 );
19136  }
19137  ecode4 = SWIG_AsVal_int(args(2), &val4);
19138  if (!SWIG_IsOK(ecode4)) {
19139  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
19140  }
19141  arg4 = (PLINT)(val4);
19142  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
19143  _outv = octave_value();
19144  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19145  {
19146 
19147  }
19148  {
19149 
19150  }
19151 fail:
19152  return _out;
19153 }
19154 
19155 
19156 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
19157  PLINT arg1 ;
19158  PLFLT *arg2 = (PLFLT *) 0 ;
19159  PLFLT *arg3 = (PLFLT *) 0 ;
19160  PLFLT *arg4 = (PLFLT *) 0 ;
19161  PLINT arg5 ;
19162  Matrix temp1 ;
19163  Matrix temp3 ;
19164  Matrix temp4 ;
19165  int val5 ;
19166  int ecode5 = 0 ;
19167  octave_value_list _out;
19168  octave_value_list *_outp=&_out;
19169  octave_value _outv;
19170 
19171  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
19172  SWIG_fail;
19173  }
19174  {
19175  if ( _n_dims( args(0) ) > 1 )
19176  {
19177  error( "argument must be a scalar or vector" ); SWIG_fail;
19178  }
19179  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19180  temp1 = args(0).matrix_value();
19181  arg2 = &temp1( 0, 0 );
19182  }
19183  {
19184  if ( _n_dims( args(1) ) > 1 )
19185  {
19186  error( "argument must be a scalar or vector" ); SWIG_fail;
19187  }
19188  if ( _dim( args(1), 0 ) != Alen )
19189  {
19190  error( "argument vectors must be same length" ); SWIG_fail;
19191  }
19192  temp3 = args(1).matrix_value();
19193  arg3 = &temp3( 0, 0 );
19194  }
19195  {
19196  if ( _n_dims( args(2) ) > 1 )
19197  {
19198  error( "argument must be a scalar or vector" ); SWIG_fail;
19199  }
19200  if ( _dim( args(2), 0 ) != Alen )
19201  {
19202  error( "argument vectors must be same length" ); SWIG_fail;
19203  }
19204  temp4 = args(2).matrix_value();
19205  arg4 = &temp4( 0, 0 );
19206  }
19207  ecode5 = SWIG_AsVal_int(args(3), &val5);
19208  if (!SWIG_IsOK(ecode5)) {
19209  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
19210  }
19211  arg5 = (PLINT)(val5);
19212  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
19213  _outv = octave_value();
19214  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19215  {
19216 
19217  }
19218  {
19219 
19220  }
19221  {
19222 
19223  }
19224 fail:
19225  return _out;
19226 }
19227 
19228 
19229 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
19230  PLINT arg1 ;
19231  PLFLT *arg2 = (PLFLT *) 0 ;
19232  PLFLT *arg3 = (PLFLT *) 0 ;
19233  PLFLT *arg4 = (PLFLT *) 0 ;
19234  PLBOOL *arg5 = (PLBOOL *) 0 ;
19235  PLBOOL arg6 ;
19236  Matrix temp1 ;
19237  Matrix temp3 ;
19238  Matrix temp4 ;
19239  Matrix temp5 ;
19240  int val6 ;
19241  int ecode6 = 0 ;
19242  octave_value_list _out;
19243  octave_value_list *_outp=&_out;
19244  octave_value _outv;
19245 
19246  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
19247  SWIG_fail;
19248  }
19249  {
19250  if ( _n_dims( args(0) ) > 1 )
19251  {
19252  error( "argument must be a scalar or vector" ); SWIG_fail;
19253  }
19254  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19255  temp1 = args(0).matrix_value();
19256  arg2 = &temp1( 0, 0 );
19257  }
19258  {
19259  if ( _n_dims( args(1) ) > 1 )
19260  {
19261  error( "argument must be a scalar or vector" ); SWIG_fail;
19262  }
19263  if ( _dim( args(1), 0 ) != Alen )
19264  {
19265  error( "argument vectors must be same length" ); SWIG_fail;
19266  }
19267  temp3 = args(1).matrix_value();
19268  arg3 = &temp3( 0, 0 );
19269  }
19270  {
19271  if ( _n_dims( args(2) ) > 1 )
19272  {
19273  error( "argument must be a scalar or vector" ); SWIG_fail;
19274  }
19275  if ( _dim( args(2), 0 ) != Alen )
19276  {
19277  error( "argument vectors must be same length" ); SWIG_fail;
19278  }
19279  temp4 = args(2).matrix_value();
19280  arg4 = &temp4( 0, 0 );
19281  }
19282  {
19283  if ( _n_dims( args(3) ) > 1 )
19284  {
19285  error( "argument must be a scalar or vector" ); SWIG_fail;
19286  }
19287  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
19288  {
19289  error( "argument vector must be same length or one less" ); SWIG_fail;
19290  }
19291  temp5 = args(3).matrix_value();
19292  arg5 = new PLINT[Alen];
19293  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
19294  }
19295  ecode6 = SWIG_AsVal_int(args(4), &val6);
19296  if (!SWIG_IsOK(ecode6)) {
19297  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
19298  }
19299  arg6 = (PLBOOL)(val6);
19300  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
19301  _outv = octave_value();
19302  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19303  {
19304 
19305  }
19306  {
19307 
19308  }
19309  {
19310 
19311  }
19312  {
19313  delete [] arg5;
19314  }
19315 fail:
19316  return _out;
19317 }
19318 
19319 
19320 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
19321  PLINT arg1 ;
19322  PLINT arg2 ;
19323  int val1 ;
19324  int ecode1 = 0 ;
19325  int val2 ;
19326  int ecode2 = 0 ;
19327  octave_value_list _out;
19328  octave_value_list *_outp=&_out;
19329  octave_value _outv;
19330 
19331  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
19332  SWIG_fail;
19333  }
19334  ecode1 = SWIG_AsVal_int(args(0), &val1);
19335  if (!SWIG_IsOK(ecode1)) {
19336  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
19337  }
19338  arg1 = (PLINT)(val1);
19339  ecode2 = SWIG_AsVal_int(args(1), &val2);
19340  if (!SWIG_IsOK(ecode2)) {
19341  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
19342  }
19343  arg2 = (PLINT)(val2);
19344  plprec(arg1,arg2);
19345  _outv = octave_value();
19346  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19347 fail:
19348  return _out;
19349 }
19350 
19351 
19352 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
19353  PLINT arg1 ;
19354  int val1 ;
19355  int ecode1 = 0 ;
19356  octave_value_list _out;
19357  octave_value_list *_outp=&_out;
19358  octave_value _outv;
19359 
19360  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
19361  SWIG_fail;
19362  }
19363  ecode1 = SWIG_AsVal_int(args(0), &val1);
19364  if (!SWIG_IsOK(ecode1)) {
19365  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
19366  }
19367  arg1 = (PLINT)(val1);
19368  plpsty(arg1);
19369  _outv = octave_value();
19370  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19371 fail:
19372  return _out;
19373 }
19374 
19375 
19376 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
19377  PLFLT arg1 ;
19378  PLFLT arg2 ;
19379  PLFLT arg3 ;
19380  PLFLT arg4 ;
19381  PLFLT arg5 ;
19382  char *arg6 = (char *) 0 ;
19383  double val1 ;
19384  int ecode1 = 0 ;
19385  double val2 ;
19386  int ecode2 = 0 ;
19387  double val3 ;
19388  int ecode3 = 0 ;
19389  double val4 ;
19390  int ecode4 = 0 ;
19391  double val5 ;
19392  int ecode5 = 0 ;
19393  int res6 ;
19394  char *buf6 = 0 ;
19395  int alloc6 = 0 ;
19396  octave_value_list _out;
19397  octave_value_list *_outp=&_out;
19398  octave_value _outv;
19399 
19400  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
19401  SWIG_fail;
19402  }
19403  ecode1 = SWIG_AsVal_double(args(0), &val1);
19404  if (!SWIG_IsOK(ecode1)) {
19405  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
19406  }
19407  arg1 = (PLFLT)(val1);
19408  ecode2 = SWIG_AsVal_double(args(1), &val2);
19409  if (!SWIG_IsOK(ecode2)) {
19410  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
19411  }
19412  arg2 = (PLFLT)(val2);
19413  ecode3 = SWIG_AsVal_double(args(2), &val3);
19414  if (!SWIG_IsOK(ecode3)) {
19415  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
19416  }
19417  arg3 = (PLFLT)(val3);
19418  ecode4 = SWIG_AsVal_double(args(3), &val4);
19419  if (!SWIG_IsOK(ecode4)) {
19420  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
19421  }
19422  arg4 = (PLFLT)(val4);
19423  ecode5 = SWIG_AsVal_double(args(4), &val5);
19424  if (!SWIG_IsOK(ecode5)) {
19425  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
19426  }
19427  arg5 = (PLFLT)(val5);
19428  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
19429  if (!SWIG_IsOK(res6)) {
19430  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
19431  }
19432  arg6 = (char *)(buf6);
19433  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
19434  _outv = octave_value();
19435  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19436  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
19437 fail:
19438  return _out;
19439 }
19440 
19441 
19442 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
19443  PLFLT arg1 ;
19444  PLFLT arg2 ;
19445  PLFLT arg3 ;
19446  PLFLT arg4 ;
19447  PLFLT arg5 ;
19448  PLFLT arg6 ;
19449  PLFLT arg7 ;
19450  PLFLT arg8 ;
19451  PLFLT arg9 ;
19452  PLFLT arg10 ;
19453  char *arg11 = (char *) 0 ;
19454  double val1 ;
19455  int ecode1 = 0 ;
19456  double val2 ;
19457  int ecode2 = 0 ;
19458  double val3 ;
19459  int ecode3 = 0 ;
19460  double val4 ;
19461  int ecode4 = 0 ;
19462  double val5 ;
19463  int ecode5 = 0 ;
19464  double val6 ;
19465  int ecode6 = 0 ;
19466  double val7 ;
19467  int ecode7 = 0 ;
19468  double val8 ;
19469  int ecode8 = 0 ;
19470  double val9 ;
19471  int ecode9 = 0 ;
19472  double val10 ;
19473  int ecode10 = 0 ;
19474  int res11 ;
19475  char *buf11 = 0 ;
19476  int alloc11 = 0 ;
19477  octave_value_list _out;
19478  octave_value_list *_outp=&_out;
19479  octave_value _outv;
19480 
19481  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
19482  SWIG_fail;
19483  }
19484  ecode1 = SWIG_AsVal_double(args(0), &val1);
19485  if (!SWIG_IsOK(ecode1)) {
19486  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
19487  }
19488  arg1 = (PLFLT)(val1);
19489  ecode2 = SWIG_AsVal_double(args(1), &val2);
19490  if (!SWIG_IsOK(ecode2)) {
19491  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
19492  }
19493  arg2 = (PLFLT)(val2);
19494  ecode3 = SWIG_AsVal_double(args(2), &val3);
19495  if (!SWIG_IsOK(ecode3)) {
19496  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
19497  }
19498  arg3 = (PLFLT)(val3);
19499  ecode4 = SWIG_AsVal_double(args(3), &val4);
19500  if (!SWIG_IsOK(ecode4)) {
19501  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
19502  }
19503  arg4 = (PLFLT)(val4);
19504  ecode5 = SWIG_AsVal_double(args(4), &val5);
19505  if (!SWIG_IsOK(ecode5)) {
19506  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
19507  }
19508  arg5 = (PLFLT)(val5);
19509  ecode6 = SWIG_AsVal_double(args(5), &val6);
19510  if (!SWIG_IsOK(ecode6)) {
19511  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
19512  }
19513  arg6 = (PLFLT)(val6);
19514  ecode7 = SWIG_AsVal_double(args(6), &val7);
19515  if (!SWIG_IsOK(ecode7)) {
19516  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
19517  }
19518  arg7 = (PLFLT)(val7);
19519  ecode8 = SWIG_AsVal_double(args(7), &val8);
19520  if (!SWIG_IsOK(ecode8)) {
19521  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
19522  }
19523  arg8 = (PLFLT)(val8);
19524  ecode9 = SWIG_AsVal_double(args(8), &val9);
19525  if (!SWIG_IsOK(ecode9)) {
19526  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
19527  }
19528  arg9 = (PLFLT)(val9);
19529  ecode10 = SWIG_AsVal_double(args(9), &val10);
19530  if (!SWIG_IsOK(ecode10)) {
19531  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
19532  }
19533  arg10 = (PLFLT)(val10);
19534  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
19535  if (!SWIG_IsOK(res11)) {
19536  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
19537  }
19538  arg11 = (char *)(buf11);
19539  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
19540  _outv = octave_value();
19541  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19542  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
19543 fail:
19544  return _out;
19545 }
19546 
19547 
19548 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
19549  octave_value_list _out;
19550  octave_value_list *_outp=&_out;
19551  octave_value _outv;
19552  PLFLT result;
19553 
19554  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
19555  SWIG_fail;
19556  }
19557  result = (PLFLT)plrandd();
19558  _outv = SWIG_From_double((double)(result));
19559  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19560 fail:
19561  return _out;
19562 }
19563 
19564 
19565 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
19566  octave_value_list _out;
19567  octave_value_list *_outp=&_out;
19568  octave_value _outv;
19569 
19570  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
19571  SWIG_fail;
19572  }
19573  plreplot();
19574  _outv = octave_value();
19575  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19576 fail:
19577  return _out;
19578 }
19579 
19580 
19581 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
19582  PLFLT arg1 ;
19583  PLFLT arg2 ;
19584  PLFLT arg3 ;
19585  PLFLT *arg4 = (PLFLT *) 0 ;
19586  PLFLT *arg5 = (PLFLT *) 0 ;
19587  PLFLT *arg6 = (PLFLT *) 0 ;
19588  double val1 ;
19589  int ecode1 = 0 ;
19590  double val2 ;
19591  int ecode2 = 0 ;
19592  double val3 ;
19593  int ecode3 = 0 ;
19594  PLFLT temp4 ;
19595  int res4 = SWIG_TMPOBJ ;
19596  PLFLT temp5 ;
19597  int res5 = SWIG_TMPOBJ ;
19598  PLFLT temp6 ;
19599  int res6 = SWIG_TMPOBJ ;
19600  octave_value_list _out;
19601  octave_value_list *_outp=&_out;
19602  octave_value _outv;
19603 
19604  arg4 = &temp4;
19605  arg5 = &temp5;
19606  arg6 = &temp6;
19607  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
19608  SWIG_fail;
19609  }
19610  ecode1 = SWIG_AsVal_double(args(0), &val1);
19611  if (!SWIG_IsOK(ecode1)) {
19612  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
19613  }
19614  arg1 = (PLFLT)(val1);
19615  ecode2 = SWIG_AsVal_double(args(1), &val2);
19616  if (!SWIG_IsOK(ecode2)) {
19617  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
19618  }
19619  arg2 = (PLFLT)(val2);
19620  ecode3 = SWIG_AsVal_double(args(2), &val3);
19621  if (!SWIG_IsOK(ecode3)) {
19622  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
19623  }
19624  arg3 = (PLFLT)(val3);
19625  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
19626  _outv = octave_value();
19627  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19628  if (SWIG_IsTmpObj(res4)) {
19629  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19630  } else {
19631  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19632  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19633  }
19634  if (SWIG_IsTmpObj(res5)) {
19635  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19636  } else {
19637  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19638  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19639  }
19640  if (SWIG_IsTmpObj(res6)) {
19641  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
19642  } else {
19643  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19644  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
19645  }
19646 fail:
19647  return _out;
19648 }
19649 
19650 
19651 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
19652  PLFLT arg1 ;
19653  PLFLT arg2 ;
19654  double val1 ;
19655  int ecode1 = 0 ;
19656  double val2 ;
19657  int ecode2 = 0 ;
19658  octave_value_list _out;
19659  octave_value_list *_outp=&_out;
19660  octave_value _outv;
19661 
19662  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
19663  SWIG_fail;
19664  }
19665  ecode1 = SWIG_AsVal_double(args(0), &val1);
19666  if (!SWIG_IsOK(ecode1)) {
19667  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
19668  }
19669  arg1 = (PLFLT)(val1);
19670  ecode2 = SWIG_AsVal_double(args(1), &val2);
19671  if (!SWIG_IsOK(ecode2)) {
19672  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
19673  }
19674  arg2 = (PLFLT)(val2);
19675  plschr(arg1,arg2);
19676  _outv = octave_value();
19677  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19678 fail:
19679  return _out;
19680 }
19681 
19682 
19683 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
19684  PLINT *arg1 = (PLINT *) 0 ;
19685  PLINT *arg2 = (PLINT *) 0 ;
19686  PLINT *arg3 = (PLINT *) 0 ;
19687  PLINT arg4 ;
19688  Matrix temp1 ;
19689  Matrix temp2 ;
19690  Matrix temp3 ;
19691  octave_value_list _out;
19692  octave_value_list *_outp=&_out;
19693  octave_value _outv;
19694 
19695  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
19696  SWIG_fail;
19697  }
19698  {
19699  if ( _n_dims( args(0) ) > 1 )
19700  {
19701  error( "argument must be a scalar or vector" ); SWIG_fail;
19702  }
19703  Alen = (PLINT) ( _dim( args(0), 0 ) );
19704  temp1 = args(0).matrix_value();
19705  arg1 = new PLINT[Alen];
19706  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19707  }
19708  {
19709  if ( _n_dims( args(1) ) > 1 )
19710  {
19711  error( "argument must be a scalar or vector" ); SWIG_fail;
19712  }
19713  if ( _dim( args(1), 0 ) != Alen )
19714  {
19715  error( "argument vectors must be same length" ); SWIG_fail;
19716  }
19717  temp2 = args(1).matrix_value();
19718  arg2 = new PLINT[Alen];
19719  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19720  }
19721  {
19722  if ( _n_dims( args(2) ) > 1 )
19723  {
19724  error( "argument must be a scalar or vector" ); SWIG_fail;
19725  }
19726  if ( _dim( args(2), 0 ) != Alen )
19727  {
19728  error( "argument vectors must be same length" ); SWIG_fail;
19729  }
19730  temp3 = args(2).matrix_value();
19731  arg3 = new PLINT[Alen];
19732  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19733  arg4 = Alen;
19734  }
19735  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
19736  _outv = octave_value();
19737  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19738  {
19739  delete [] arg1;
19740  }
19741  {
19742  delete [] arg2;
19743  }
19744  {
19745  delete [] arg3;
19746  }
19747 fail:
19748  return _out;
19749 }
19750 
19751 
19752 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
19753  PLINT *arg1 = (PLINT *) 0 ;
19754  PLINT *arg2 = (PLINT *) 0 ;
19755  PLINT *arg3 = (PLINT *) 0 ;
19756  PLFLT *arg4 = (PLFLT *) 0 ;
19757  PLINT arg5 ;
19758  Matrix temp1 ;
19759  Matrix temp2 ;
19760  Matrix temp3 ;
19761  Matrix temp4 ;
19762  octave_value_list _out;
19763  octave_value_list *_outp=&_out;
19764  octave_value _outv;
19765 
19766  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
19767  SWIG_fail;
19768  }
19769  {
19770  if ( _n_dims( args(0) ) > 1 )
19771  {
19772  error( "argument must be a scalar or vector" ); SWIG_fail;
19773  }
19774  Alen = (PLINT) ( _dim( args(0), 0 ) );
19775  temp1 = args(0).matrix_value();
19776  arg1 = new PLINT[Alen];
19777  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19778  }
19779  {
19780  if ( _n_dims( args(1) ) > 1 )
19781  {
19782  error( "argument must be a scalar or vector" ); SWIG_fail;
19783  }
19784  if ( _dim( args(1), 0 ) != Alen )
19785  {
19786  error( "argument vectors must be same length" ); SWIG_fail;
19787  }
19788  temp2 = args(1).matrix_value();
19789  arg2 = new PLINT[Alen];
19790  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19791  }
19792  {
19793  if ( _n_dims( args(2) ) > 1 )
19794  {
19795  error( "argument must be a scalar or vector" ); SWIG_fail;
19796  }
19797  if ( _dim( args(2), 0 ) != Alen )
19798  {
19799  error( "argument vectors must be same length" ); SWIG_fail;
19800  }
19801  temp3 = args(2).matrix_value();
19802  arg3 = new PLINT[Alen];
19803  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19804  }
19805  {
19806  if ( _n_dims( args(3) ) > 1 )
19807  {
19808  error( "argument must be a scalar or vector" ); SWIG_fail;
19809  }
19810  if ( _dim( args(3), 0 ) != Alen )
19811  {
19812  error( "argument vectors must be same length" ); SWIG_fail;
19813  }
19814  temp4 = args(3).matrix_value();
19815  arg4 = &temp4( 0, 0 );
19816  arg5 = (PLINT) ( _dim( args(3), 0 ) );
19817  }
19818  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
19819  _outv = octave_value();
19820  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19821  {
19822  delete [] arg1;
19823  }
19824  {
19825  delete [] arg2;
19826  }
19827  {
19828  delete [] arg3;
19829  }
19830  {
19831 
19832  }
19833 fail:
19834  return _out;
19835 }
19836 
19837 
19838 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
19839  PLINT arg1 ;
19840  int val1 ;
19841  int ecode1 = 0 ;
19842  octave_value_list _out;
19843  octave_value_list *_outp=&_out;
19844  octave_value _outv;
19845 
19846  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
19847  SWIG_fail;
19848  }
19849  ecode1 = SWIG_AsVal_int(args(0), &val1);
19850  if (!SWIG_IsOK(ecode1)) {
19851  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
19852  }
19853  arg1 = (PLINT)(val1);
19854  plscmap0n(arg1);
19855  _outv = octave_value();
19856  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19857 fail:
19858  return _out;
19859 }
19860 
19861 
19862 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
19863  PLINT *arg1 = (PLINT *) 0 ;
19864  PLINT *arg2 = (PLINT *) 0 ;
19865  PLINT *arg3 = (PLINT *) 0 ;
19866  PLINT arg4 ;
19867  Matrix temp1 ;
19868  Matrix temp2 ;
19869  Matrix temp3 ;
19870  octave_value_list _out;
19871  octave_value_list *_outp=&_out;
19872  octave_value _outv;
19873 
19874  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
19875  SWIG_fail;
19876  }
19877  {
19878  if ( _n_dims( args(0) ) > 1 )
19879  {
19880  error( "argument must be a scalar or vector" ); SWIG_fail;
19881  }
19882  Alen = (PLINT) ( _dim( args(0), 0 ) );
19883  temp1 = args(0).matrix_value();
19884  arg1 = new PLINT[Alen];
19885  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19886  }
19887  {
19888  if ( _n_dims( args(1) ) > 1 )
19889  {
19890  error( "argument must be a scalar or vector" ); SWIG_fail;
19891  }
19892  if ( _dim( args(1), 0 ) != Alen )
19893  {
19894  error( "argument vectors must be same length" ); SWIG_fail;
19895  }
19896  temp2 = args(1).matrix_value();
19897  arg2 = new PLINT[Alen];
19898  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19899  }
19900  {
19901  if ( _n_dims( args(2) ) > 1 )
19902  {
19903  error( "argument must be a scalar or vector" ); SWIG_fail;
19904  }
19905  if ( _dim( args(2), 0 ) != Alen )
19906  {
19907  error( "argument vectors must be same length" ); SWIG_fail;
19908  }
19909  temp3 = args(2).matrix_value();
19910  arg3 = new PLINT[Alen];
19911  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19912  arg4 = Alen;
19913  }
19914  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
19915  _outv = octave_value();
19916  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19917  {
19918  delete [] arg1;
19919  }
19920  {
19921  delete [] arg2;
19922  }
19923  {
19924  delete [] arg3;
19925  }
19926 fail:
19927  return _out;
19928 }
19929 
19930 
19931 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
19932  PLINT *arg1 = (PLINT *) 0 ;
19933  PLINT *arg2 = (PLINT *) 0 ;
19934  PLINT *arg3 = (PLINT *) 0 ;
19935  PLFLT *arg4 = (PLFLT *) 0 ;
19936  PLINT arg5 ;
19937  Matrix temp1 ;
19938  Matrix temp2 ;
19939  Matrix temp3 ;
19940  Matrix temp4 ;
19941  octave_value_list _out;
19942  octave_value_list *_outp=&_out;
19943  octave_value _outv;
19944 
19945  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
19946  SWIG_fail;
19947  }
19948  {
19949  if ( _n_dims( args(0) ) > 1 )
19950  {
19951  error( "argument must be a scalar or vector" ); SWIG_fail;
19952  }
19953  Alen = (PLINT) ( _dim( args(0), 0 ) );
19954  temp1 = args(0).matrix_value();
19955  arg1 = new PLINT[Alen];
19956  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19957  }
19958  {
19959  if ( _n_dims( args(1) ) > 1 )
19960  {
19961  error( "argument must be a scalar or vector" ); SWIG_fail;
19962  }
19963  if ( _dim( args(1), 0 ) != Alen )
19964  {
19965  error( "argument vectors must be same length" ); SWIG_fail;
19966  }
19967  temp2 = args(1).matrix_value();
19968  arg2 = new PLINT[Alen];
19969  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19970  }
19971  {
19972  if ( _n_dims( args(2) ) > 1 )
19973  {
19974  error( "argument must be a scalar or vector" ); SWIG_fail;
19975  }
19976  if ( _dim( args(2), 0 ) != Alen )
19977  {
19978  error( "argument vectors must be same length" ); SWIG_fail;
19979  }
19980  temp3 = args(2).matrix_value();
19981  arg3 = new PLINT[Alen];
19982  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19983  }
19984  {
19985  if ( _n_dims( args(3) ) > 1 )
19986  {
19987  error( "argument must be a scalar or vector" ); SWIG_fail;
19988  }
19989  if ( _dim( args(3), 0 ) != Alen )
19990  {
19991  error( "argument vectors must be same length" ); SWIG_fail;
19992  }
19993  temp4 = args(3).matrix_value();
19994  arg4 = &temp4( 0, 0 );
19995  arg5 = (PLINT) ( _dim( args(3), 0 ) );
19996  }
19997  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
19998  _outv = octave_value();
19999  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20000  {
20001  delete [] arg1;
20002  }
20003  {
20004  delete [] arg2;
20005  }
20006  {
20007  delete [] arg3;
20008  }
20009  {
20010 
20011  }
20012 fail:
20013  return _out;
20014 }
20015 
20016 
20017 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
20018  PLBOOL arg1 ;
20019  PLINT arg2 ;
20020  PLFLT *arg3 = (PLFLT *) 0 ;
20021  PLFLT *arg4 = (PLFLT *) 0 ;
20022  PLFLT *arg5 = (PLFLT *) 0 ;
20023  PLFLT *arg6 = (PLFLT *) 0 ;
20024  PLBOOL *arg7 = (PLBOOL *) 0 ;
20025  int val1 ;
20026  int ecode1 = 0 ;
20027  Matrix temp2 ;
20028  Matrix temp4 ;
20029  Matrix temp5 ;
20030  Matrix temp6 ;
20031  Matrix temp7 ;
20032  octave_value_list _out;
20033  octave_value_list *_outp=&_out;
20034  octave_value _outv;
20035 
20036  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
20037  SWIG_fail;
20038  }
20039  ecode1 = SWIG_AsVal_int(args(0), &val1);
20040  if (!SWIG_IsOK(ecode1)) {
20041  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
20042  }
20043  arg1 = (PLBOOL)(val1);
20044  {
20045  if ( _n_dims( args(1) ) > 1 )
20046  {
20047  error( "argument must be a scalar or vector" ); SWIG_fail;
20048  }
20049  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
20050  temp2 = args(1).matrix_value();
20051  arg3 = &temp2( 0, 0 );
20052  }
20053  {
20054  if ( _n_dims( args(2) ) > 1 )
20055  {
20056  error( "argument must be a scalar or vector" ); SWIG_fail;
20057  }
20058  if ( _dim( args(2), 0 ) != Alen )
20059  {
20060  error( "argument vectors must be same length" ); SWIG_fail;
20061  }
20062  temp4 = args(2).matrix_value();
20063  arg4 = &temp4( 0, 0 );
20064  }
20065  {
20066  if ( _n_dims( args(3) ) > 1 )
20067  {
20068  error( "argument must be a scalar or vector" ); SWIG_fail;
20069  }
20070  if ( _dim( args(3), 0 ) != Alen )
20071  {
20072  error( "argument vectors must be same length" ); SWIG_fail;
20073  }
20074  temp5 = args(3).matrix_value();
20075  arg5 = &temp5( 0, 0 );
20076  }
20077  {
20078  if ( _n_dims( args(4) ) > 1 )
20079  {
20080  error( "argument must be a scalar or vector" ); SWIG_fail;
20081  }
20082  if ( _dim( args(4), 0 ) != Alen )
20083  {
20084  error( "argument vectors must be same length" ); SWIG_fail;
20085  }
20086  temp6 = args(4).matrix_value();
20087  arg6 = &temp6( 0, 0 );
20088  }
20089  {
20090  if ( _n_dims( args(5) ) > 1 )
20091  {
20092  error( "argument must be a scalar or vector" ); SWIG_fail;
20093  }
20094  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
20095  {
20096  error( "argument vector must be same length or one less" ); SWIG_fail;
20097  }
20098  temp7 = args(5).matrix_value();
20099  arg7 = new PLINT[Alen];
20100  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
20101  }
20102  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
20103  _outv = octave_value();
20104  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20105  {
20106 
20107  }
20108  {
20109 
20110  }
20111  {
20112 
20113  }
20114  {
20115 
20116  }
20117  {
20118  delete [] arg7;
20119  }
20120 fail:
20121  return _out;
20122 }
20123 
20124 
20125 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
20126  PLBOOL arg1 ;
20127  PLINT arg2 ;
20128  PLFLT *arg3 = (PLFLT *) 0 ;
20129  PLFLT *arg4 = (PLFLT *) 0 ;
20130  PLFLT *arg5 = (PLFLT *) 0 ;
20131  PLFLT *arg6 = (PLFLT *) 0 ;
20132  PLFLT *arg7 = (PLFLT *) 0 ;
20133  PLBOOL *arg8 = (PLBOOL *) 0 ;
20134  int val1 ;
20135  int ecode1 = 0 ;
20136  Matrix temp2 ;
20137  Matrix temp4 ;
20138  Matrix temp5 ;
20139  Matrix temp6 ;
20140  Matrix temp7 ;
20141  Matrix temp8 ;
20142  octave_value_list _out;
20143  octave_value_list *_outp=&_out;
20144  octave_value _outv;
20145 
20146  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
20147  SWIG_fail;
20148  }
20149  ecode1 = SWIG_AsVal_int(args(0), &val1);
20150  if (!SWIG_IsOK(ecode1)) {
20151  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
20152  }
20153  arg1 = (PLBOOL)(val1);
20154  {
20155  if ( _n_dims( args(1) ) > 1 )
20156  {
20157  error( "argument must be a scalar or vector" ); SWIG_fail;
20158  }
20159  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
20160  temp2 = args(1).matrix_value();
20161  arg3 = &temp2( 0, 0 );
20162  }
20163  {
20164  if ( _n_dims( args(2) ) > 1 )
20165  {
20166  error( "argument must be a scalar or vector" ); SWIG_fail;
20167  }
20168  if ( _dim( args(2), 0 ) != Alen )
20169  {
20170  error( "argument vectors must be same length" ); SWIG_fail;
20171  }
20172  temp4 = args(2).matrix_value();
20173  arg4 = &temp4( 0, 0 );
20174  }
20175  {
20176  if ( _n_dims( args(3) ) > 1 )
20177  {
20178  error( "argument must be a scalar or vector" ); SWIG_fail;
20179  }
20180  if ( _dim( args(3), 0 ) != Alen )
20181  {
20182  error( "argument vectors must be same length" ); SWIG_fail;
20183  }
20184  temp5 = args(3).matrix_value();
20185  arg5 = &temp5( 0, 0 );
20186  }
20187  {
20188  if ( _n_dims( args(4) ) > 1 )
20189  {
20190  error( "argument must be a scalar or vector" ); SWIG_fail;
20191  }
20192  if ( _dim( args(4), 0 ) != Alen )
20193  {
20194  error( "argument vectors must be same length" ); SWIG_fail;
20195  }
20196  temp6 = args(4).matrix_value();
20197  arg6 = &temp6( 0, 0 );
20198  }
20199  {
20200  if ( _n_dims( args(5) ) > 1 )
20201  {
20202  error( "argument must be a scalar or vector" ); SWIG_fail;
20203  }
20204  if ( _dim( args(5), 0 ) != Alen )
20205  {
20206  error( "argument vectors must be same length" ); SWIG_fail;
20207  }
20208  temp7 = args(5).matrix_value();
20209  arg7 = &temp7( 0, 0 );
20210  }
20211  {
20212  if ( _n_dims( args(6) ) > 1 )
20213  {
20214  error( "argument must be a scalar or vector" ); SWIG_fail;
20215  }
20216  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
20217  {
20218  error( "argument vector must be same length or one less" ); SWIG_fail;
20219  }
20220  temp8 = args(6).matrix_value();
20221  arg8 = new PLINT[Alen];
20222  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
20223  }
20224  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
20225  _outv = octave_value();
20226  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20227  {
20228 
20229  }
20230  {
20231 
20232  }
20233  {
20234 
20235  }
20236  {
20237 
20238  }
20239  {
20240 
20241  }
20242  {
20243  delete [] arg8;
20244  }
20245 fail:
20246  return _out;
20247 }
20248 
20249 
20250 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
20251  PLINT arg1 ;
20252  int val1 ;
20253  int ecode1 = 0 ;
20254  octave_value_list _out;
20255  octave_value_list *_outp=&_out;
20256  octave_value _outv;
20257 
20258  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
20259  SWIG_fail;
20260  }
20261  ecode1 = SWIG_AsVal_int(args(0), &val1);
20262  if (!SWIG_IsOK(ecode1)) {
20263  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
20264  }
20265  arg1 = (PLINT)(val1);
20266  plscmap1n(arg1);
20267  _outv = octave_value();
20268  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20269 fail:
20270  return _out;
20271 }
20272 
20273 
20274 SWIG_DEFUN( plscmap1_range, _wrap_plscmap1_range, _wrap_plscmap1_range_texinfo ) {
20275  PLFLT arg1 ;
20276  PLFLT arg2 ;
20277  double val1 ;
20278  int ecode1 = 0 ;
20279  double val2 ;
20280  int ecode2 = 0 ;
20281  octave_value_list _out;
20282  octave_value_list *_outp=&_out;
20283  octave_value _outv;
20284 
20285  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
20286  SWIG_fail;
20287  }
20288  ecode1 = SWIG_AsVal_double(args(0), &val1);
20289  if (!SWIG_IsOK(ecode1)) {
20290  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
20291  }
20292  arg1 = (PLFLT)(val1);
20293  ecode2 = SWIG_AsVal_double(args(1), &val2);
20294  if (!SWIG_IsOK(ecode2)) {
20295  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
20296  }
20297  arg2 = (PLFLT)(val2);
20298  plscmap1_range(arg1,arg2);
20299  _outv = octave_value();
20300  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20301 fail:
20302  return _out;
20303 }
20304 
20305 
20306 SWIG_DEFUN( plgcmap1_range, _wrap_plgcmap1_range, _wrap_plgcmap1_range_texinfo ) {
20307  PLFLT *arg1 = (PLFLT *) 0 ;
20308  PLFLT *arg2 = (PLFLT *) 0 ;
20309  PLFLT temp1 ;
20310  int res1 = SWIG_TMPOBJ ;
20311  PLFLT temp2 ;
20312  int res2 = SWIG_TMPOBJ ;
20313  octave_value_list _out;
20314  octave_value_list *_outp=&_out;
20315  octave_value _outv;
20316 
20317  arg1 = &temp1;
20318  arg2 = &temp2;
20319  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
20320  SWIG_fail;
20321  }
20322  plgcmap1_range(arg1,arg2);
20323  _outv = octave_value();
20324  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20325  if (SWIG_IsTmpObj(res1)) {
20326  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20327  } else {
20328  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20329  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20330  }
20331  if (SWIG_IsTmpObj(res2)) {
20332  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20333  } else {
20334  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20335  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20336  }
20337 fail:
20338  return _out;
20339 }
20340 
20341 
20342 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
20343  PLINT arg1 ;
20344  PLINT arg2 ;
20345  PLINT arg3 ;
20346  PLINT arg4 ;
20347  int val1 ;
20348  int ecode1 = 0 ;
20349  int val2 ;
20350  int ecode2 = 0 ;
20351  int val3 ;
20352  int ecode3 = 0 ;
20353  int val4 ;
20354  int ecode4 = 0 ;
20355  octave_value_list _out;
20356  octave_value_list *_outp=&_out;
20357  octave_value _outv;
20358 
20359  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
20360  SWIG_fail;
20361  }
20362  ecode1 = SWIG_AsVal_int(args(0), &val1);
20363  if (!SWIG_IsOK(ecode1)) {
20364  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
20365  }
20366  arg1 = (PLINT)(val1);
20367  ecode2 = SWIG_AsVal_int(args(1), &val2);
20368  if (!SWIG_IsOK(ecode2)) {
20369  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
20370  }
20371  arg2 = (PLINT)(val2);
20372  ecode3 = SWIG_AsVal_int(args(2), &val3);
20373  if (!SWIG_IsOK(ecode3)) {
20374  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
20375  }
20376  arg3 = (PLINT)(val3);
20377  ecode4 = SWIG_AsVal_int(args(3), &val4);
20378  if (!SWIG_IsOK(ecode4)) {
20379  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
20380  }
20381  arg4 = (PLINT)(val4);
20382  plscol0(arg1,arg2,arg3,arg4);
20383  _outv = octave_value();
20384  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20385 fail:
20386  return _out;
20387 }
20388 
20389 
20390 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
20391  PLINT arg1 ;
20392  PLINT arg2 ;
20393  PLINT arg3 ;
20394  PLINT arg4 ;
20395  PLFLT arg5 ;
20396  int val1 ;
20397  int ecode1 = 0 ;
20398  int val2 ;
20399  int ecode2 = 0 ;
20400  int val3 ;
20401  int ecode3 = 0 ;
20402  int val4 ;
20403  int ecode4 = 0 ;
20404  double val5 ;
20405  int ecode5 = 0 ;
20406  octave_value_list _out;
20407  octave_value_list *_outp=&_out;
20408  octave_value _outv;
20409 
20410  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
20411  SWIG_fail;
20412  }
20413  ecode1 = SWIG_AsVal_int(args(0), &val1);
20414  if (!SWIG_IsOK(ecode1)) {
20415  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
20416  }
20417  arg1 = (PLINT)(val1);
20418  ecode2 = SWIG_AsVal_int(args(1), &val2);
20419  if (!SWIG_IsOK(ecode2)) {
20420  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
20421  }
20422  arg2 = (PLINT)(val2);
20423  ecode3 = SWIG_AsVal_int(args(2), &val3);
20424  if (!SWIG_IsOK(ecode3)) {
20425  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
20426  }
20427  arg3 = (PLINT)(val3);
20428  ecode4 = SWIG_AsVal_int(args(3), &val4);
20429  if (!SWIG_IsOK(ecode4)) {
20430  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
20431  }
20432  arg4 = (PLINT)(val4);
20433  ecode5 = SWIG_AsVal_double(args(4), &val5);
20434  if (!SWIG_IsOK(ecode5)) {
20435  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
20436  }
20437  arg5 = (PLFLT)(val5);
20438  plscol0a(arg1,arg2,arg3,arg4,arg5);
20439  _outv = octave_value();
20440  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20441 fail:
20442  return _out;
20443 }
20444 
20445 
20446 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
20447  PLINT arg1 ;
20448  PLINT arg2 ;
20449  PLINT arg3 ;
20450  int val1 ;
20451  int ecode1 = 0 ;
20452  int val2 ;
20453  int ecode2 = 0 ;
20454  int val3 ;
20455  int ecode3 = 0 ;
20456  octave_value_list _out;
20457  octave_value_list *_outp=&_out;
20458  octave_value _outv;
20459 
20460  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
20461  SWIG_fail;
20462  }
20463  ecode1 = SWIG_AsVal_int(args(0), &val1);
20464  if (!SWIG_IsOK(ecode1)) {
20465  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
20466  }
20467  arg1 = (PLINT)(val1);
20468  ecode2 = SWIG_AsVal_int(args(1), &val2);
20469  if (!SWIG_IsOK(ecode2)) {
20470  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
20471  }
20472  arg2 = (PLINT)(val2);
20473  ecode3 = SWIG_AsVal_int(args(2), &val3);
20474  if (!SWIG_IsOK(ecode3)) {
20475  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
20476  }
20477  arg3 = (PLINT)(val3);
20478  plscolbg(arg1,arg2,arg3);
20479  _outv = octave_value();
20480  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20481 fail:
20482  return _out;
20483 }
20484 
20485 
20486 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
20487  PLINT arg1 ;
20488  PLINT arg2 ;
20489  PLINT arg3 ;
20490  PLFLT arg4 ;
20491  int val1 ;
20492  int ecode1 = 0 ;
20493  int val2 ;
20494  int ecode2 = 0 ;
20495  int val3 ;
20496  int ecode3 = 0 ;
20497  double val4 ;
20498  int ecode4 = 0 ;
20499  octave_value_list _out;
20500  octave_value_list *_outp=&_out;
20501  octave_value _outv;
20502 
20503  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
20504  SWIG_fail;
20505  }
20506  ecode1 = SWIG_AsVal_int(args(0), &val1);
20507  if (!SWIG_IsOK(ecode1)) {
20508  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
20509  }
20510  arg1 = (PLINT)(val1);
20511  ecode2 = SWIG_AsVal_int(args(1), &val2);
20512  if (!SWIG_IsOK(ecode2)) {
20513  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
20514  }
20515  arg2 = (PLINT)(val2);
20516  ecode3 = SWIG_AsVal_int(args(2), &val3);
20517  if (!SWIG_IsOK(ecode3)) {
20518  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
20519  }
20520  arg3 = (PLINT)(val3);
20521  ecode4 = SWIG_AsVal_double(args(3), &val4);
20522  if (!SWIG_IsOK(ecode4)) {
20523  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
20524  }
20525  arg4 = (PLFLT)(val4);
20526  plscolbga(arg1,arg2,arg3,arg4);
20527  _outv = octave_value();
20528  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20529 fail:
20530  return _out;
20531 }
20532 
20533 
20534 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
20535  PLINT arg1 ;
20536  int val1 ;
20537  int ecode1 = 0 ;
20538  octave_value_list _out;
20539  octave_value_list *_outp=&_out;
20540  octave_value _outv;
20541 
20542  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
20543  SWIG_fail;
20544  }
20545  ecode1 = SWIG_AsVal_int(args(0), &val1);
20546  if (!SWIG_IsOK(ecode1)) {
20547  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
20548  }
20549  arg1 = (PLINT)(val1);
20550  plscolor(arg1);
20551  _outv = octave_value();
20552  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20553 fail:
20554  return _out;
20555 }
20556 
20557 
20558 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
20559  PLINT arg1 ;
20560  int val1 ;
20561  int ecode1 = 0 ;
20562  octave_value_list _out;
20563  octave_value_list *_outp=&_out;
20564  octave_value _outv;
20565 
20566  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
20567  SWIG_fail;
20568  }
20569  ecode1 = SWIG_AsVal_int(args(0), &val1);
20570  if (!SWIG_IsOK(ecode1)) {
20571  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
20572  }
20573  arg1 = (PLINT)(val1);
20574  plscompression(arg1);
20575  _outv = octave_value();
20576  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20577 fail:
20578  return _out;
20579 }
20580 
20581 
20582 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
20583  char *arg1 = (char *) 0 ;
20584  int res1 ;
20585  char *buf1 = 0 ;
20586  int alloc1 = 0 ;
20587  octave_value_list _out;
20588  octave_value_list *_outp=&_out;
20589  octave_value _outv;
20590 
20591  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
20592  SWIG_fail;
20593  }
20594  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20595  if (!SWIG_IsOK(res1)) {
20596  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
20597  }
20598  arg1 = (char *)(buf1);
20599  plsdev((char const *)arg1);
20600  _outv = octave_value();
20601  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20602  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20603 fail:
20604  return _out;
20605 }
20606 
20607 
20608 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
20609  PLFLT arg1 ;
20610  PLFLT arg2 ;
20611  PLFLT arg3 ;
20612  PLFLT arg4 ;
20613  double val1 ;
20614  int ecode1 = 0 ;
20615  double val2 ;
20616  int ecode2 = 0 ;
20617  double val3 ;
20618  int ecode3 = 0 ;
20619  double val4 ;
20620  int ecode4 = 0 ;
20621  octave_value_list _out;
20622  octave_value_list *_outp=&_out;
20623  octave_value _outv;
20624 
20625  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
20626  SWIG_fail;
20627  }
20628  ecode1 = SWIG_AsVal_double(args(0), &val1);
20629  if (!SWIG_IsOK(ecode1)) {
20630  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
20631  }
20632  arg1 = (PLFLT)(val1);
20633  ecode2 = SWIG_AsVal_double(args(1), &val2);
20634  if (!SWIG_IsOK(ecode2)) {
20635  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
20636  }
20637  arg2 = (PLFLT)(val2);
20638  ecode3 = SWIG_AsVal_double(args(2), &val3);
20639  if (!SWIG_IsOK(ecode3)) {
20640  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
20641  }
20642  arg3 = (PLFLT)(val3);
20643  ecode4 = SWIG_AsVal_double(args(3), &val4);
20644  if (!SWIG_IsOK(ecode4)) {
20645  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
20646  }
20647  arg4 = (PLFLT)(val4);
20648  plsdidev(arg1,arg2,arg3,arg4);
20649  _outv = octave_value();
20650  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20651 fail:
20652  return _out;
20653 }
20654 
20655 
20656 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
20657  PLINT arg1 ;
20658  PLINT arg2 ;
20659  PLINT arg3 ;
20660  PLINT arg4 ;
20661  PLFLT arg5 ;
20662  PLFLT arg6 ;
20663  int val1 ;
20664  int ecode1 = 0 ;
20665  int val2 ;
20666  int ecode2 = 0 ;
20667  int val3 ;
20668  int ecode3 = 0 ;
20669  int val4 ;
20670  int ecode4 = 0 ;
20671  double val5 ;
20672  int ecode5 = 0 ;
20673  double val6 ;
20674  int ecode6 = 0 ;
20675  octave_value_list _out;
20676  octave_value_list *_outp=&_out;
20677  octave_value _outv;
20678 
20679  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
20680  SWIG_fail;
20681  }
20682  ecode1 = SWIG_AsVal_int(args(0), &val1);
20683  if (!SWIG_IsOK(ecode1)) {
20684  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
20685  }
20686  arg1 = (PLINT)(val1);
20687  ecode2 = SWIG_AsVal_int(args(1), &val2);
20688  if (!SWIG_IsOK(ecode2)) {
20689  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
20690  }
20691  arg2 = (PLINT)(val2);
20692  ecode3 = SWIG_AsVal_int(args(2), &val3);
20693  if (!SWIG_IsOK(ecode3)) {
20694  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
20695  }
20696  arg3 = (PLINT)(val3);
20697  ecode4 = SWIG_AsVal_int(args(3), &val4);
20698  if (!SWIG_IsOK(ecode4)) {
20699  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
20700  }
20701  arg4 = (PLINT)(val4);
20702  ecode5 = SWIG_AsVal_double(args(4), &val5);
20703  if (!SWIG_IsOK(ecode5)) {
20704  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
20705  }
20706  arg5 = (PLFLT)(val5);
20707  ecode6 = SWIG_AsVal_double(args(5), &val6);
20708  if (!SWIG_IsOK(ecode6)) {
20709  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
20710  }
20711  arg6 = (PLFLT)(val6);
20712  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
20713  _outv = octave_value();
20714  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20715 fail:
20716  return _out;
20717 }
20718 
20719 
20720 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
20721  PLFLT arg1 ;
20722  double val1 ;
20723  int ecode1 = 0 ;
20724  octave_value_list _out;
20725  octave_value_list *_outp=&_out;
20726  octave_value _outv;
20727 
20728  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
20729  SWIG_fail;
20730  }
20731  ecode1 = SWIG_AsVal_double(args(0), &val1);
20732  if (!SWIG_IsOK(ecode1)) {
20733  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
20734  }
20735  arg1 = (PLFLT)(val1);
20736  plsdiori(arg1);
20737  _outv = octave_value();
20738  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20739 fail:
20740  return _out;
20741 }
20742 
20743 
20744 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
20745  PLFLT arg1 ;
20746  PLFLT arg2 ;
20747  PLFLT arg3 ;
20748  PLFLT arg4 ;
20749  double val1 ;
20750  int ecode1 = 0 ;
20751  double val2 ;
20752  int ecode2 = 0 ;
20753  double val3 ;
20754  int ecode3 = 0 ;
20755  double val4 ;
20756  int ecode4 = 0 ;
20757  octave_value_list _out;
20758  octave_value_list *_outp=&_out;
20759  octave_value _outv;
20760 
20761  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
20762  SWIG_fail;
20763  }
20764  ecode1 = SWIG_AsVal_double(args(0), &val1);
20765  if (!SWIG_IsOK(ecode1)) {
20766  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
20767  }
20768  arg1 = (PLFLT)(val1);
20769  ecode2 = SWIG_AsVal_double(args(1), &val2);
20770  if (!SWIG_IsOK(ecode2)) {
20771  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
20772  }
20773  arg2 = (PLFLT)(val2);
20774  ecode3 = SWIG_AsVal_double(args(2), &val3);
20775  if (!SWIG_IsOK(ecode3)) {
20776  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
20777  }
20778  arg3 = (PLFLT)(val3);
20779  ecode4 = SWIG_AsVal_double(args(3), &val4);
20780  if (!SWIG_IsOK(ecode4)) {
20781  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
20782  }
20783  arg4 = (PLFLT)(val4);
20784  plsdiplt(arg1,arg2,arg3,arg4);
20785  _outv = octave_value();
20786  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20787 fail:
20788  return _out;
20789 }
20790 
20791 
20792 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
20793  PLFLT arg1 ;
20794  PLFLT arg2 ;
20795  PLFLT arg3 ;
20796  PLFLT arg4 ;
20797  double val1 ;
20798  int ecode1 = 0 ;
20799  double val2 ;
20800  int ecode2 = 0 ;
20801  double val3 ;
20802  int ecode3 = 0 ;
20803  double val4 ;
20804  int ecode4 = 0 ;
20805  octave_value_list _out;
20806  octave_value_list *_outp=&_out;
20807  octave_value _outv;
20808 
20809  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
20810  SWIG_fail;
20811  }
20812  ecode1 = SWIG_AsVal_double(args(0), &val1);
20813  if (!SWIG_IsOK(ecode1)) {
20814  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
20815  }
20816  arg1 = (PLFLT)(val1);
20817  ecode2 = SWIG_AsVal_double(args(1), &val2);
20818  if (!SWIG_IsOK(ecode2)) {
20819  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
20820  }
20821  arg2 = (PLFLT)(val2);
20822  ecode3 = SWIG_AsVal_double(args(2), &val3);
20823  if (!SWIG_IsOK(ecode3)) {
20824  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
20825  }
20826  arg3 = (PLFLT)(val3);
20827  ecode4 = SWIG_AsVal_double(args(3), &val4);
20828  if (!SWIG_IsOK(ecode4)) {
20829  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
20830  }
20831  arg4 = (PLFLT)(val4);
20832  plsdiplz(arg1,arg2,arg3,arg4);
20833  _outv = octave_value();
20834  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20835 fail:
20836  return _out;
20837 }
20838 
20839 
20840 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
20841  unsigned int arg1 ;
20842  unsigned int val1 ;
20843  int ecode1 = 0 ;
20844  octave_value_list _out;
20845  octave_value_list *_outp=&_out;
20846  octave_value _outv;
20847 
20848  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
20849  SWIG_fail;
20850  }
20851  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
20852  if (!SWIG_IsOK(ecode1)) {
20853  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
20854  }
20855  arg1 = (unsigned int)(val1);
20856  plseed(arg1);
20857  _outv = octave_value();
20858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20859 fail:
20860  return _out;
20861 }
20862 
20863 
20864 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
20865  char arg1 ;
20866  char val1 ;
20867  int ecode1 = 0 ;
20868  octave_value_list _out;
20869  octave_value_list *_outp=&_out;
20870  octave_value _outv;
20871 
20872  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
20873  SWIG_fail;
20874  }
20875  ecode1 = SWIG_AsVal_char(args(0), &val1);
20876  if (!SWIG_IsOK(ecode1)) {
20877  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
20878  }
20879  arg1 = (char)(val1);
20880  plsesc(arg1);
20881  _outv = octave_value();
20882  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20883 fail:
20884  return _out;
20885 }
20886 
20887 
20888 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
20889  char *arg1 = (char *) 0 ;
20890  char *arg2 = (char *) 0 ;
20891  int res1 ;
20892  char *buf1 = 0 ;
20893  int alloc1 = 0 ;
20894  int res2 ;
20895  char *buf2 = 0 ;
20896  int alloc2 = 0 ;
20897  octave_value_list _out;
20898  octave_value_list *_outp=&_out;
20899  octave_value _outv;
20900  PLINT result;
20901 
20902  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
20903  SWIG_fail;
20904  }
20905  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20906  if (!SWIG_IsOK(res1)) {
20907  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
20908  }
20909  arg1 = (char *)(buf1);
20910  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20911  if (!SWIG_IsOK(res2)) {
20912  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
20913  }
20914  arg2 = (char *)(buf2);
20915  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
20916  _outv = SWIG_From_int((int)(result));
20917  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20918  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20919  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20920 fail:
20921  return _out;
20922 }
20923 
20924 
20925 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
20926  PLINT arg1 ;
20927  PLINT arg2 ;
20928  PLINT arg3 ;
20929  int val1 ;
20930  int ecode1 = 0 ;
20931  int val2 ;
20932  int ecode2 = 0 ;
20933  int val3 ;
20934  int ecode3 = 0 ;
20935  octave_value_list _out;
20936  octave_value_list *_outp=&_out;
20937  octave_value _outv;
20938 
20939  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
20940  SWIG_fail;
20941  }
20942  ecode1 = SWIG_AsVal_int(args(0), &val1);
20943  if (!SWIG_IsOK(ecode1)) {
20944  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
20945  }
20946  arg1 = (PLINT)(val1);
20947  ecode2 = SWIG_AsVal_int(args(1), &val2);
20948  if (!SWIG_IsOK(ecode2)) {
20949  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
20950  }
20951  arg2 = (PLINT)(val2);
20952  ecode3 = SWIG_AsVal_int(args(2), &val3);
20953  if (!SWIG_IsOK(ecode3)) {
20954  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
20955  }
20956  arg3 = (PLINT)(val3);
20957  plsfam(arg1,arg2,arg3);
20958  _outv = octave_value();
20959  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20960 fail:
20961  return _out;
20962 }
20963 
20964 
20965 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
20966  PLUNICODE arg1 ;
20967  unsigned int val1 ;
20968  int ecode1 = 0 ;
20969  octave_value_list _out;
20970  octave_value_list *_outp=&_out;
20971  octave_value _outv;
20972 
20973  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
20974  SWIG_fail;
20975  }
20976  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
20977  if (!SWIG_IsOK(ecode1)) {
20978  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
20979  }
20980  arg1 = (PLUNICODE)(val1);
20981  plsfci(arg1);
20982  _outv = octave_value();
20983  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20984 fail:
20985  return _out;
20986 }
20987 
20988 
20989 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
20990  char *arg1 = (char *) 0 ;
20991  int res1 ;
20992  char *buf1 = 0 ;
20993  int alloc1 = 0 ;
20994  octave_value_list _out;
20995  octave_value_list *_outp=&_out;
20996  octave_value _outv;
20997 
20998  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
20999  SWIG_fail;
21000  }
21001  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21002  if (!SWIG_IsOK(res1)) {
21003  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
21004  }
21005  arg1 = (char *)(buf1);
21006  plsfnam((char const *)arg1);
21007  _outv = octave_value();
21008  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21009  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21010 fail:
21011  return _out;
21012 }
21013 
21014 
21015 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
21016  PLINT arg1 ;
21017  PLINT arg2 ;
21018  PLINT arg3 ;
21019  int val1 ;
21020  int ecode1 = 0 ;
21021  int val2 ;
21022  int ecode2 = 0 ;
21023  int val3 ;
21024  int ecode3 = 0 ;
21025  octave_value_list _out;
21026  octave_value_list *_outp=&_out;
21027  octave_value _outv;
21028 
21029  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
21030  SWIG_fail;
21031  }
21032  ecode1 = SWIG_AsVal_int(args(0), &val1);
21033  if (!SWIG_IsOK(ecode1)) {
21034  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
21035  }
21036  arg1 = (PLINT)(val1);
21037  ecode2 = SWIG_AsVal_int(args(1), &val2);
21038  if (!SWIG_IsOK(ecode2)) {
21039  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
21040  }
21041  arg2 = (PLINT)(val2);
21042  ecode3 = SWIG_AsVal_int(args(2), &val3);
21043  if (!SWIG_IsOK(ecode3)) {
21044  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
21045  }
21046  arg3 = (PLINT)(val3);
21047  plsfont(arg1,arg2,arg3);
21048  _outv = octave_value();
21049  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21050 fail:
21051  return _out;
21052 }
21053 
21054 
21055 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
21056  label_func arg1 = (label_func) 0 ;
21057  PLPointer arg2 = (PLPointer) 0 ;
21058  int res2 ;
21059  octave_value_list _out;
21060  octave_value_list *_outp=&_out;
21061  octave_value _outv;
21062 
21063  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
21064  SWIG_fail;
21065  }
21066  {
21067  octave_value obj = args(0);
21068  if ( !obj.is_empty() )
21069  {
21070  if ( obj.is_function_handle() || obj.is_inline_function() )
21071  {
21072  fcnLabelFunc = obj.function_value();
21073  }
21074  else if ( obj.is_string() )
21075  {
21076  nameLabelFunc = obj.string_value();
21077  fcnLabelFunc = NULL;
21078  }
21079  arg1 = labelfunc_octave;
21080  }
21081  else
21082  {
21083  arg1 = NULL;
21084  }
21085  }
21086  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
21087  if (!SWIG_IsOK(res2)) {
21088  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
21089  }
21090  plslabelfunc(arg1,arg2);
21091  _outv = octave_value();
21092  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21093 fail:
21094  return _out;
21095 }
21096 
21097 
21098 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
21099  PLFLT arg1 ;
21100  PLFLT arg2 ;
21101  double val1 ;
21102  int ecode1 = 0 ;
21103  double val2 ;
21104  int ecode2 = 0 ;
21105  octave_value_list _out;
21106  octave_value_list *_outp=&_out;
21107  octave_value _outv;
21108 
21109  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
21110  SWIG_fail;
21111  }
21112  ecode1 = SWIG_AsVal_double(args(0), &val1);
21113  if (!SWIG_IsOK(ecode1)) {
21114  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
21115  }
21116  arg1 = (PLFLT)(val1);
21117  ecode2 = SWIG_AsVal_double(args(1), &val2);
21118  if (!SWIG_IsOK(ecode2)) {
21119  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
21120  }
21121  arg2 = (PLFLT)(val2);
21122  plsmaj(arg1,arg2);
21123  _outv = octave_value();
21124  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21125 fail:
21126  return _out;
21127 }
21128 
21129 
21130 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
21131  PLFLT arg1 ;
21132  PLFLT arg2 ;
21133  double val1 ;
21134  int ecode1 = 0 ;
21135  double val2 ;
21136  int ecode2 = 0 ;
21137  octave_value_list _out;
21138  octave_value_list *_outp=&_out;
21139  octave_value _outv;
21140 
21141  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
21142  SWIG_fail;
21143  }
21144  ecode1 = SWIG_AsVal_double(args(0), &val1);
21145  if (!SWIG_IsOK(ecode1)) {
21146  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
21147  }
21148  arg1 = (PLFLT)(val1);
21149  ecode2 = SWIG_AsVal_double(args(1), &val2);
21150  if (!SWIG_IsOK(ecode2)) {
21151  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
21152  }
21153  arg2 = (PLFLT)(val2);
21154  plsmin(arg1,arg2);
21155  _outv = octave_value();
21156  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21157 fail:
21158  return _out;
21159 }
21160 
21161 
21162 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
21163  PLINT arg1 ;
21164  int val1 ;
21165  int ecode1 = 0 ;
21166  octave_value_list _out;
21167  octave_value_list *_outp=&_out;
21168  octave_value _outv;
21169 
21170  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
21171  SWIG_fail;
21172  }
21173  ecode1 = SWIG_AsVal_int(args(0), &val1);
21174  if (!SWIG_IsOK(ecode1)) {
21175  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
21176  }
21177  arg1 = (PLINT)(val1);
21178  plsori(arg1);
21179  _outv = octave_value();
21180  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21181 fail:
21182  return _out;
21183 }
21184 
21185 
21186 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
21187  PLFLT arg1 ;
21188  PLFLT arg2 ;
21189  PLINT arg3 ;
21190  PLINT arg4 ;
21191  PLINT arg5 ;
21192  PLINT arg6 ;
21193  double val1 ;
21194  int ecode1 = 0 ;
21195  double val2 ;
21196  int ecode2 = 0 ;
21197  int val3 ;
21198  int ecode3 = 0 ;
21199  int val4 ;
21200  int ecode4 = 0 ;
21201  int val5 ;
21202  int ecode5 = 0 ;
21203  int val6 ;
21204  int ecode6 = 0 ;
21205  octave_value_list _out;
21206  octave_value_list *_outp=&_out;
21207  octave_value _outv;
21208 
21209  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
21210  SWIG_fail;
21211  }
21212  ecode1 = SWIG_AsVal_double(args(0), &val1);
21213  if (!SWIG_IsOK(ecode1)) {
21214  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
21215  }
21216  arg1 = (PLFLT)(val1);
21217  ecode2 = SWIG_AsVal_double(args(1), &val2);
21218  if (!SWIG_IsOK(ecode2)) {
21219  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
21220  }
21221  arg2 = (PLFLT)(val2);
21222  ecode3 = SWIG_AsVal_int(args(2), &val3);
21223  if (!SWIG_IsOK(ecode3)) {
21224  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
21225  }
21226  arg3 = (PLINT)(val3);
21227  ecode4 = SWIG_AsVal_int(args(3), &val4);
21228  if (!SWIG_IsOK(ecode4)) {
21229  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
21230  }
21231  arg4 = (PLINT)(val4);
21232  ecode5 = SWIG_AsVal_int(args(4), &val5);
21233  if (!SWIG_IsOK(ecode5)) {
21234  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
21235  }
21236  arg5 = (PLINT)(val5);
21237  ecode6 = SWIG_AsVal_int(args(5), &val6);
21238  if (!SWIG_IsOK(ecode6)) {
21239  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
21240  }
21241  arg6 = (PLINT)(val6);
21242  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
21243  _outv = octave_value();
21244  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21245 fail:
21246  return _out;
21247 }
21248 
21249 
21250 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
21251  char *arg1 = (char *) 0 ;
21252  int res1 ;
21253  char *buf1 = 0 ;
21254  int alloc1 = 0 ;
21255  octave_value_list _out;
21256  octave_value_list *_outp=&_out;
21257  octave_value _outv;
21258 
21259  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
21260  SWIG_fail;
21261  }
21262  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21263  if (!SWIG_IsOK(res1)) {
21264  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
21265  }
21266  arg1 = (char *)(buf1);
21267  plspal0((char const *)arg1);
21268  _outv = octave_value();
21269  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21270  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21271 fail:
21272  return _out;
21273 }
21274 
21275 
21276 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
21277  char *arg1 = (char *) 0 ;
21278  PLBOOL arg2 ;
21279  int res1 ;
21280  char *buf1 = 0 ;
21281  int alloc1 = 0 ;
21282  int val2 ;
21283  int ecode2 = 0 ;
21284  octave_value_list _out;
21285  octave_value_list *_outp=&_out;
21286  octave_value _outv;
21287 
21288  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
21289  SWIG_fail;
21290  }
21291  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21292  if (!SWIG_IsOK(res1)) {
21293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
21294  }
21295  arg1 = (char *)(buf1);
21296  ecode2 = SWIG_AsVal_int(args(1), &val2);
21297  if (!SWIG_IsOK(ecode2)) {
21298  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
21299  }
21300  arg2 = (PLBOOL)(val2);
21301  plspal1((char const *)arg1,arg2);
21302  _outv = octave_value();
21303  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21304  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21305 fail:
21306  return _out;
21307 }
21308 
21309 
21310 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
21311  PLBOOL arg1 ;
21312  int val1 ;
21313  int ecode1 = 0 ;
21314  octave_value_list _out;
21315  octave_value_list *_outp=&_out;
21316  octave_value _outv;
21317 
21318  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
21319  SWIG_fail;
21320  }
21321  ecode1 = SWIG_AsVal_int(args(0), &val1);
21322  if (!SWIG_IsOK(ecode1)) {
21323  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
21324  }
21325  arg1 = (PLBOOL)(val1);
21326  plspause(arg1);
21327  _outv = octave_value();
21328  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21329 fail:
21330  return _out;
21331 }
21332 
21333 
21334 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
21335  PLINT arg1 ;
21336  int val1 ;
21337  int ecode1 = 0 ;
21338  octave_value_list _out;
21339  octave_value_list *_outp=&_out;
21340  octave_value _outv;
21341 
21342  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
21343  SWIG_fail;
21344  }
21345  ecode1 = SWIG_AsVal_int(args(0), &val1);
21346  if (!SWIG_IsOK(ecode1)) {
21347  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
21348  }
21349  arg1 = (PLINT)(val1);
21350  plsstrm(arg1);
21351  _outv = octave_value();
21352  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21353 fail:
21354  return _out;
21355 }
21356 
21357 
21358 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
21359  PLINT arg1 ;
21360  PLINT arg2 ;
21361  int val1 ;
21362  int ecode1 = 0 ;
21363  int val2 ;
21364  int ecode2 = 0 ;
21365  octave_value_list _out;
21366  octave_value_list *_outp=&_out;
21367  octave_value _outv;
21368 
21369  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
21370  SWIG_fail;
21371  }
21372  ecode1 = SWIG_AsVal_int(args(0), &val1);
21373  if (!SWIG_IsOK(ecode1)) {
21374  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
21375  }
21376  arg1 = (PLINT)(val1);
21377  ecode2 = SWIG_AsVal_int(args(1), &val2);
21378  if (!SWIG_IsOK(ecode2)) {
21379  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
21380  }
21381  arg2 = (PLINT)(val2);
21382  plssub(arg1,arg2);
21383  _outv = octave_value();
21384  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21385 fail:
21386  return _out;
21387 }
21388 
21389 
21390 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
21391  PLFLT arg1 ;
21392  PLFLT arg2 ;
21393  double val1 ;
21394  int ecode1 = 0 ;
21395  double val2 ;
21396  int ecode2 = 0 ;
21397  octave_value_list _out;
21398  octave_value_list *_outp=&_out;
21399  octave_value _outv;
21400 
21401  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
21402  SWIG_fail;
21403  }
21404  ecode1 = SWIG_AsVal_double(args(0), &val1);
21405  if (!SWIG_IsOK(ecode1)) {
21406  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
21407  }
21408  arg1 = (PLFLT)(val1);
21409  ecode2 = SWIG_AsVal_double(args(1), &val2);
21410  if (!SWIG_IsOK(ecode2)) {
21411  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
21412  }
21413  arg2 = (PLFLT)(val2);
21414  plssym(arg1,arg2);
21415  _outv = octave_value();
21416  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21417 fail:
21418  return _out;
21419 }
21420 
21421 
21422 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
21423  PLINT arg1 ;
21424  PLINT arg2 ;
21425  int val1 ;
21426  int ecode1 = 0 ;
21427  int val2 ;
21428  int ecode2 = 0 ;
21429  octave_value_list _out;
21430  octave_value_list *_outp=&_out;
21431  octave_value _outv;
21432 
21433  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
21434  SWIG_fail;
21435  }
21436  ecode1 = SWIG_AsVal_int(args(0), &val1);
21437  if (!SWIG_IsOK(ecode1)) {
21438  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
21439  }
21440  arg1 = (PLINT)(val1);
21441  ecode2 = SWIG_AsVal_int(args(1), &val2);
21442  if (!SWIG_IsOK(ecode2)) {
21443  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
21444  }
21445  arg2 = (PLINT)(val2);
21446  plstar(arg1,arg2);
21447  _outv = octave_value();
21448  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21449 fail:
21450  return _out;
21451 }
21452 
21453 
21454 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
21455  char *arg1 = (char *) 0 ;
21456  PLINT arg2 ;
21457  PLINT arg3 ;
21458  int res1 ;
21459  char *buf1 = 0 ;
21460  int alloc1 = 0 ;
21461  int val2 ;
21462  int ecode2 = 0 ;
21463  int val3 ;
21464  int ecode3 = 0 ;
21465  octave_value_list _out;
21466  octave_value_list *_outp=&_out;
21467  octave_value _outv;
21468 
21469  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
21470  SWIG_fail;
21471  }
21472  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21473  if (!SWIG_IsOK(res1)) {
21474  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
21475  }
21476  arg1 = (char *)(buf1);
21477  ecode2 = SWIG_AsVal_int(args(1), &val2);
21478  if (!SWIG_IsOK(ecode2)) {
21479  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
21480  }
21481  arg2 = (PLINT)(val2);
21482  ecode3 = SWIG_AsVal_int(args(2), &val3);
21483  if (!SWIG_IsOK(ecode3)) {
21484  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
21485  }
21486  arg3 = (PLINT)(val3);
21487  plstart((char const *)arg1,arg2,arg3);
21488  _outv = octave_value();
21489  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21490  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21491 fail:
21492  return _out;
21493 }
21494 
21495 
21496 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
21497  ct_func arg1 = (ct_func) 0 ;
21498  PLPointer arg2 = (PLPointer) 0 ;
21499  int res2 ;
21500  octave_value_list _out;
21501  octave_value_list *_outp=&_out;
21502  octave_value _outv;
21503 
21504  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
21505  SWIG_fail;
21506  }
21507  {
21508  octave_value obj = args(0);
21509  if ( !obj.is_empty() )
21510  {
21511  if ( obj.is_function_handle() || obj.is_inline_function() )
21512  {
21513  fcnCoordTrans = obj.function_value();
21514  }
21515  else if ( obj.is_string() )
21516  {
21517  nameCoordTrans = obj.string_value();
21518  fcnCoordTrans = NULL;
21519  }
21520  arg1 = ct_octave;
21521  }
21522  else
21523  {
21524  arg1 = NULL;
21525  }
21526  }
21527  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
21528  if (!SWIG_IsOK(res2)) {
21529  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
21530  }
21531  plstransform(arg1,arg2);
21532  _outv = octave_value();
21533  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21534 fail:
21535  return _out;
21536 }
21537 
21538 
21539 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
21540  PLINT arg1 ;
21541  PLFLT *arg2 = (PLFLT *) 0 ;
21542  PLFLT *arg3 = (PLFLT *) 0 ;
21543  char *arg4 = (char *) 0 ;
21544  Matrix temp1 ;
21545  Matrix temp3 ;
21546  int res4 ;
21547  char *buf4 = 0 ;
21548  int alloc4 = 0 ;
21549  octave_value_list _out;
21550  octave_value_list *_outp=&_out;
21551  octave_value _outv;
21552 
21553  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
21554  SWIG_fail;
21555  }
21556  {
21557  if ( _n_dims( args(0) ) > 1 )
21558  {
21559  error( "argument must be a scalar or vector" ); SWIG_fail;
21560  }
21561  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21562  temp1 = args(0).matrix_value();
21563  arg2 = &temp1( 0, 0 );
21564  }
21565  {
21566  if ( _n_dims( args(1) ) > 1 )
21567  {
21568  error( "argument must be a scalar or vector" ); SWIG_fail;
21569  }
21570  if ( _dim( args(1), 0 ) != Alen )
21571  {
21572  error( "argument vectors must be same length" ); SWIG_fail;
21573  }
21574  temp3 = args(1).matrix_value();
21575  arg3 = &temp3( 0, 0 );
21576  }
21577  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
21578  if (!SWIG_IsOK(res4)) {
21579  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
21580  }
21581  arg4 = (char *)(buf4);
21582  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
21583  _outv = octave_value();
21584  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21585  {
21586 
21587  }
21588  {
21589 
21590  }
21591  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
21592 fail:
21593  return _out;
21594 }
21595 
21596 
21597 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
21598  PLINT arg1 ;
21599  PLFLT *arg2 = (PLFLT *) 0 ;
21600  PLFLT *arg3 = (PLFLT *) 0 ;
21601  PLFLT *arg4 = (PLFLT *) 0 ;
21602  char *arg5 = (char *) 0 ;
21603  Matrix temp1 ;
21604  Matrix temp3 ;
21605  Matrix temp4 ;
21606  int res5 ;
21607  char *buf5 = 0 ;
21608  int alloc5 = 0 ;
21609  octave_value_list _out;
21610  octave_value_list *_outp=&_out;
21611  octave_value _outv;
21612 
21613  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
21614  SWIG_fail;
21615  }
21616  {
21617  if ( _n_dims( args(0) ) > 1 )
21618  {
21619  error( "argument must be a scalar or vector" ); SWIG_fail;
21620  }
21621  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21622  temp1 = args(0).matrix_value();
21623  arg2 = &temp1( 0, 0 );
21624  }
21625  {
21626  if ( _n_dims( args(1) ) > 1 )
21627  {
21628  error( "argument must be a scalar or vector" ); SWIG_fail;
21629  }
21630  if ( _dim( args(1), 0 ) != Alen )
21631  {
21632  error( "argument vectors must be same length" ); SWIG_fail;
21633  }
21634  temp3 = args(1).matrix_value();
21635  arg3 = &temp3( 0, 0 );
21636  }
21637  {
21638  if ( _n_dims( args(2) ) > 1 )
21639  {
21640  error( "argument must be a scalar or vector" ); SWIG_fail;
21641  }
21642  if ( _dim( args(2), 0 ) != Alen )
21643  {
21644  error( "argument vectors must be same length" ); SWIG_fail;
21645  }
21646  temp4 = args(2).matrix_value();
21647  arg4 = &temp4( 0, 0 );
21648  }
21649  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
21650  if (!SWIG_IsOK(res5)) {
21651  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
21652  }
21653  arg5 = (char *)(buf5);
21654  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
21655  _outv = octave_value();
21656  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21657  {
21658 
21659  }
21660  {
21661 
21662  }
21663  {
21664 
21665  }
21666  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21667 fail:
21668  return _out;
21669 }
21670 
21671 
21672 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
21673  PLINT arg1 ;
21674  PLINT arg2 ;
21675  PLFLT arg3 ;
21676  PLFLT arg4 ;
21677  int val1 ;
21678  int ecode1 = 0 ;
21679  int val2 ;
21680  int ecode2 = 0 ;
21681  double val3 ;
21682  int ecode3 = 0 ;
21683  double val4 ;
21684  int ecode4 = 0 ;
21685  octave_value_list _out;
21686  octave_value_list *_outp=&_out;
21687  octave_value _outv;
21688 
21689  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
21690  SWIG_fail;
21691  }
21692  ecode1 = SWIG_AsVal_int(args(0), &val1);
21693  if (!SWIG_IsOK(ecode1)) {
21694  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
21695  }
21696  arg1 = (PLINT)(val1);
21697  ecode2 = SWIG_AsVal_int(args(1), &val2);
21698  if (!SWIG_IsOK(ecode2)) {
21699  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
21700  }
21701  arg2 = (PLINT)(val2);
21702  ecode3 = SWIG_AsVal_double(args(2), &val3);
21703  if (!SWIG_IsOK(ecode3)) {
21704  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
21705  }
21706  arg3 = (PLFLT)(val3);
21707  ecode4 = SWIG_AsVal_double(args(3), &val4);
21708  if (!SWIG_IsOK(ecode4)) {
21709  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
21710  }
21711  arg4 = (PLFLT)(val4);
21712  plstripa(arg1,arg2,arg3,arg4);
21713  _outv = octave_value();
21714  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21715 fail:
21716  return _out;
21717 }
21718 
21719 
21720 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
21721  PLINT arg1 ;
21722  int val1 ;
21723  int ecode1 = 0 ;
21724  octave_value_list _out;
21725  octave_value_list *_outp=&_out;
21726  octave_value _outv;
21727 
21728  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
21729  SWIG_fail;
21730  }
21731  ecode1 = SWIG_AsVal_int(args(0), &val1);
21732  if (!SWIG_IsOK(ecode1)) {
21733  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
21734  }
21735  arg1 = (PLINT)(val1);
21736  plstripd(arg1);
21737  _outv = octave_value();
21738  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21739 fail:
21740  return _out;
21741 }
21742 
21743 
21744 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
21745  PLINT arg1 ;
21746  PLINT *arg2 = (PLINT *) 0 ;
21747  PLINT *arg3 = (PLINT *) 0 ;
21748  Matrix temp1 ;
21749  Matrix temp3 ;
21750  octave_value_list _out;
21751  octave_value_list *_outp=&_out;
21752  octave_value _outv;
21753 
21754  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
21755  SWIG_fail;
21756  }
21757  {
21758  if ( _n_dims( args(0) ) > 1 )
21759  {
21760  error( "argument must be a scalar or vector" ); SWIG_fail;
21761  }
21762  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21763  arg2 = new PLINT[Alen];
21764  temp1 = args(0).matrix_value();
21765  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21766  }
21767  {
21768  if ( _n_dims( args(1) ) > 1 )
21769  {
21770  error( "argument must be a scalar or vector" ); SWIG_fail;
21771  }
21772  if ( _dim( args(1), 0 ) != Alen )
21773  {
21774  error( "argument vectors must be same length" ); SWIG_fail;
21775  }
21776  temp3 = args(1).matrix_value();
21777  arg3 = new PLINT[Alen];
21778  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21779  }
21780  plstyl(arg1,(int const *)arg2,(int const *)arg3);
21781  _outv = octave_value();
21782  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21783  {
21784  delete [] arg2;
21785  }
21786  {
21787  delete [] arg3;
21788  }
21789 fail:
21790  return _out;
21791 }
21792 
21793 
21794 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
21795  PLFLT *arg1 = (PLFLT *) 0 ;
21796  PLFLT *arg2 = (PLFLT *) 0 ;
21797  PLINT arg3 ;
21798  PLBOOL arg4 ;
21799  Matrix temp1 ;
21800  Matrix temp2 ;
21801  int val4 ;
21802  int ecode4 = 0 ;
21803  octave_value_list _out;
21804  octave_value_list *_outp=&_out;
21805  octave_value _outv;
21806 
21807  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
21808  SWIG_fail;
21809  }
21810  {
21811  if ( _n_dims( args(0) ) > 1 )
21812  {
21813  error( "argument must be a scalar or vector" ); SWIG_fail;
21814  }
21815  if ( !args(0).is_empty() )
21816  {
21817  Alen = (PLINT) ( _dim( args(0), 0 ) );
21818  temp1 = args(0).matrix_value();
21819  arg1 = &temp1( 0, 0 );
21820  }
21821  else
21822  {
21823  arg1 = NULL;
21824  Alen = 0;
21825  }
21826  }
21827  {
21828  if ( _n_dims( args(1) ) > 1 )
21829  {
21830  error( "argument must be a scalar or vector" ); SWIG_fail;
21831  }
21832  if ( !args(1).is_empty() )
21833  {
21834  if ( _dim( args(1), 0 ) != Alen )
21835  {
21836  error( "argument vectors must be same length" ); SWIG_fail;
21837  }
21838  temp2 = args(1).matrix_value();
21839  arg2 = &temp2( 0, 0 );
21840  arg3 = (PLINT) ( _dim( args(1), 0 ) );
21841  }
21842  else
21843  {
21844  arg2 = NULL;
21845  arg3 = 0;
21846  }
21847  }
21848  ecode4 = SWIG_AsVal_int(args(2), &val4);
21849  if (!SWIG_IsOK(ecode4)) {
21850  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
21851  }
21852  arg4 = (PLBOOL)(val4);
21853  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
21854  _outv = octave_value();
21855  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21856  {
21857 
21858  }
21859  {
21860 
21861  }
21862 fail:
21863  return _out;
21864 }
21865 
21866 
21867 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
21868  PLFLT arg1 ;
21869  PLFLT arg2 ;
21870  PLFLT arg3 ;
21871  PLFLT arg4 ;
21872  double val1 ;
21873  int ecode1 = 0 ;
21874  double val2 ;
21875  int ecode2 = 0 ;
21876  double val3 ;
21877  int ecode3 = 0 ;
21878  double val4 ;
21879  int ecode4 = 0 ;
21880  octave_value_list _out;
21881  octave_value_list *_outp=&_out;
21882  octave_value _outv;
21883 
21884  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
21885  SWIG_fail;
21886  }
21887  ecode1 = SWIG_AsVal_double(args(0), &val1);
21888  if (!SWIG_IsOK(ecode1)) {
21889  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
21890  }
21891  arg1 = (PLFLT)(val1);
21892  ecode2 = SWIG_AsVal_double(args(1), &val2);
21893  if (!SWIG_IsOK(ecode2)) {
21894  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
21895  }
21896  arg2 = (PLFLT)(val2);
21897  ecode3 = SWIG_AsVal_double(args(2), &val3);
21898  if (!SWIG_IsOK(ecode3)) {
21899  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
21900  }
21901  arg3 = (PLFLT)(val3);
21902  ecode4 = SWIG_AsVal_double(args(3), &val4);
21903  if (!SWIG_IsOK(ecode4)) {
21904  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
21905  }
21906  arg4 = (PLFLT)(val4);
21907  plsvpa(arg1,arg2,arg3,arg4);
21908  _outv = octave_value();
21909  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21910 fail:
21911  return _out;
21912 }
21913 
21914 
21915 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
21916  PLINT arg1 ;
21917  PLINT arg2 ;
21918  int val1 ;
21919  int ecode1 = 0 ;
21920  int val2 ;
21921  int ecode2 = 0 ;
21922  octave_value_list _out;
21923  octave_value_list *_outp=&_out;
21924  octave_value _outv;
21925 
21926  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
21927  SWIG_fail;
21928  }
21929  ecode1 = SWIG_AsVal_int(args(0), &val1);
21930  if (!SWIG_IsOK(ecode1)) {
21931  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
21932  }
21933  arg1 = (PLINT)(val1);
21934  ecode2 = SWIG_AsVal_int(args(1), &val2);
21935  if (!SWIG_IsOK(ecode2)) {
21936  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
21937  }
21938  arg2 = (PLINT)(val2);
21939  plsxax(arg1,arg2);
21940  _outv = octave_value();
21941  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21942 fail:
21943  return _out;
21944 }
21945 
21946 
21947 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
21948  PLINT arg1 ;
21949  PLINT arg2 ;
21950  int val1 ;
21951  int ecode1 = 0 ;
21952  int val2 ;
21953  int ecode2 = 0 ;
21954  octave_value_list _out;
21955  octave_value_list *_outp=&_out;
21956  octave_value _outv;
21957 
21958  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
21959  SWIG_fail;
21960  }
21961  ecode1 = SWIG_AsVal_int(args(0), &val1);
21962  if (!SWIG_IsOK(ecode1)) {
21963  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
21964  }
21965  arg1 = (PLINT)(val1);
21966  ecode2 = SWIG_AsVal_int(args(1), &val2);
21967  if (!SWIG_IsOK(ecode2)) {
21968  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
21969  }
21970  arg2 = (PLINT)(val2);
21971  plsyax(arg1,arg2);
21972  _outv = octave_value();
21973  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21974 fail:
21975  return _out;
21976 }
21977 
21978 
21979 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
21980  PLINT arg1 ;
21981  PLFLT *arg2 = (PLFLT *) 0 ;
21982  PLFLT *arg3 = (PLFLT *) 0 ;
21983  PLINT arg4 ;
21984  Matrix temp1 ;
21985  Matrix temp3 ;
21986  int val4 ;
21987  int ecode4 = 0 ;
21988  octave_value_list _out;
21989  octave_value_list *_outp=&_out;
21990  octave_value _outv;
21991 
21992  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
21993  SWIG_fail;
21994  }
21995  {
21996  if ( _n_dims( args(0) ) > 1 )
21997  {
21998  error( "argument must be a scalar or vector" ); SWIG_fail;
21999  }
22000  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22001  temp1 = args(0).matrix_value();
22002  arg2 = &temp1( 0, 0 );
22003  }
22004  {
22005  if ( _n_dims( args(1) ) > 1 )
22006  {
22007  error( "argument must be a scalar or vector" ); SWIG_fail;
22008  }
22009  if ( _dim( args(1), 0 ) != Alen )
22010  {
22011  error( "argument vectors must be same length" ); SWIG_fail;
22012  }
22013  temp3 = args(1).matrix_value();
22014  arg3 = &temp3( 0, 0 );
22015  }
22016  ecode4 = SWIG_AsVal_int(args(2), &val4);
22017  if (!SWIG_IsOK(ecode4)) {
22018  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
22019  }
22020  arg4 = (PLINT)(val4);
22021  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
22022  _outv = octave_value();
22023  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22024  {
22025 
22026  }
22027  {
22028 
22029  }
22030 fail:
22031  return _out;
22032 }
22033 
22034 
22035 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
22036  PLINT arg1 ;
22037  PLINT arg2 ;
22038  int val1 ;
22039  int ecode1 = 0 ;
22040  int val2 ;
22041  int ecode2 = 0 ;
22042  octave_value_list _out;
22043  octave_value_list *_outp=&_out;
22044  octave_value _outv;
22045 
22046  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
22047  SWIG_fail;
22048  }
22049  ecode1 = SWIG_AsVal_int(args(0), &val1);
22050  if (!SWIG_IsOK(ecode1)) {
22051  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
22052  }
22053  arg1 = (PLINT)(val1);
22054  ecode2 = SWIG_AsVal_int(args(1), &val2);
22055  if (!SWIG_IsOK(ecode2)) {
22056  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
22057  }
22058  arg2 = (PLINT)(val2);
22059  plszax(arg1,arg2);
22060  _outv = octave_value();
22061  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22062 fail:
22063  return _out;
22064 }
22065 
22066 
22067 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
22068  octave_value_list _out;
22069  octave_value_list *_outp=&_out;
22070  octave_value _outv;
22071 
22072  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
22073  SWIG_fail;
22074  }
22075  pltext();
22076  _outv = octave_value();
22077  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22078 fail:
22079  return _out;
22080 }
22081 
22082 
22083 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
22084  char *arg1 = (char *) 0 ;
22085  int res1 ;
22086  char *buf1 = 0 ;
22087  int alloc1 = 0 ;
22088  octave_value_list _out;
22089  octave_value_list *_outp=&_out;
22090  octave_value _outv;
22091 
22092  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
22093  SWIG_fail;
22094  }
22095  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22096  if (!SWIG_IsOK(res1)) {
22097  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
22098  }
22099  arg1 = (char *)(buf1);
22100  pltimefmt((char const *)arg1);
22101  _outv = octave_value();
22102  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22103  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22104 fail:
22105  return _out;
22106 }
22107 
22108 
22109 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
22110  PLFLT arg1 ;
22111  double val1 ;
22112  int ecode1 = 0 ;
22113  octave_value_list _out;
22114  octave_value_list *_outp=&_out;
22115  octave_value _outv;
22116 
22117  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
22118  SWIG_fail;
22119  }
22120  ecode1 = SWIG_AsVal_double(args(0), &val1);
22121  if (!SWIG_IsOK(ecode1)) {
22122  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
22123  }
22124  arg1 = (PLFLT)(val1);
22125  plvasp(arg1);
22126  _outv = octave_value();
22127  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22128 fail:
22129  return _out;
22130 }
22131 
22132 
22133 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
22134  PLFLT arg1 ;
22135  PLFLT arg2 ;
22136  PLFLT arg3 ;
22137  PLFLT arg4 ;
22138  PLFLT arg5 ;
22139  double val1 ;
22140  int ecode1 = 0 ;
22141  double val2 ;
22142  int ecode2 = 0 ;
22143  double val3 ;
22144  int ecode3 = 0 ;
22145  double val4 ;
22146  int ecode4 = 0 ;
22147  double val5 ;
22148  int ecode5 = 0 ;
22149  octave_value_list _out;
22150  octave_value_list *_outp=&_out;
22151  octave_value _outv;
22152 
22153  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
22154  SWIG_fail;
22155  }
22156  ecode1 = SWIG_AsVal_double(args(0), &val1);
22157  if (!SWIG_IsOK(ecode1)) {
22158  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
22159  }
22160  arg1 = (PLFLT)(val1);
22161  ecode2 = SWIG_AsVal_double(args(1), &val2);
22162  if (!SWIG_IsOK(ecode2)) {
22163  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
22164  }
22165  arg2 = (PLFLT)(val2);
22166  ecode3 = SWIG_AsVal_double(args(2), &val3);
22167  if (!SWIG_IsOK(ecode3)) {
22168  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
22169  }
22170  arg3 = (PLFLT)(val3);
22171  ecode4 = SWIG_AsVal_double(args(3), &val4);
22172  if (!SWIG_IsOK(ecode4)) {
22173  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
22174  }
22175  arg4 = (PLFLT)(val4);
22176  ecode5 = SWIG_AsVal_double(args(4), &val5);
22177  if (!SWIG_IsOK(ecode5)) {
22178  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
22179  }
22180  arg5 = (PLFLT)(val5);
22181  plvpas(arg1,arg2,arg3,arg4,arg5);
22182  _outv = octave_value();
22183  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22184 fail:
22185  return _out;
22186 }
22187 
22188 
22189 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
22190  PLFLT arg1 ;
22191  PLFLT arg2 ;
22192  PLFLT arg3 ;
22193  PLFLT arg4 ;
22194  double val1 ;
22195  int ecode1 = 0 ;
22196  double val2 ;
22197  int ecode2 = 0 ;
22198  double val3 ;
22199  int ecode3 = 0 ;
22200  double val4 ;
22201  int ecode4 = 0 ;
22202  octave_value_list _out;
22203  octave_value_list *_outp=&_out;
22204  octave_value _outv;
22205 
22206  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
22207  SWIG_fail;
22208  }
22209  ecode1 = SWIG_AsVal_double(args(0), &val1);
22210  if (!SWIG_IsOK(ecode1)) {
22211  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
22212  }
22213  arg1 = (PLFLT)(val1);
22214  ecode2 = SWIG_AsVal_double(args(1), &val2);
22215  if (!SWIG_IsOK(ecode2)) {
22216  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
22217  }
22218  arg2 = (PLFLT)(val2);
22219  ecode3 = SWIG_AsVal_double(args(2), &val3);
22220  if (!SWIG_IsOK(ecode3)) {
22221  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
22222  }
22223  arg3 = (PLFLT)(val3);
22224  ecode4 = SWIG_AsVal_double(args(3), &val4);
22225  if (!SWIG_IsOK(ecode4)) {
22226  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
22227  }
22228  arg4 = (PLFLT)(val4);
22229  plvpor(arg1,arg2,arg3,arg4);
22230  _outv = octave_value();
22231  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22232 fail:
22233  return _out;
22234 }
22235 
22236 
22237 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
22238  octave_value_list _out;
22239  octave_value_list *_outp=&_out;
22240  octave_value _outv;
22241 
22242  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
22243  SWIG_fail;
22244  }
22245  plvsta();
22246  _outv = octave_value();
22247  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22248 fail:
22249  return _out;
22250 }
22251 
22252 
22253 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
22254  PLFLT arg1 ;
22255  PLFLT arg2 ;
22256  PLFLT arg3 ;
22257  PLFLT arg4 ;
22258  PLFLT arg5 ;
22259  PLFLT arg6 ;
22260  PLFLT arg7 ;
22261  PLFLT arg8 ;
22262  PLFLT arg9 ;
22263  PLFLT arg10 ;
22264  PLFLT arg11 ;
22265  double val1 ;
22266  int ecode1 = 0 ;
22267  double val2 ;
22268  int ecode2 = 0 ;
22269  double val3 ;
22270  int ecode3 = 0 ;
22271  double val4 ;
22272  int ecode4 = 0 ;
22273  double val5 ;
22274  int ecode5 = 0 ;
22275  double val6 ;
22276  int ecode6 = 0 ;
22277  double val7 ;
22278  int ecode7 = 0 ;
22279  double val8 ;
22280  int ecode8 = 0 ;
22281  double val9 ;
22282  int ecode9 = 0 ;
22283  double val10 ;
22284  int ecode10 = 0 ;
22285  double val11 ;
22286  int ecode11 = 0 ;
22287  octave_value_list _out;
22288  octave_value_list *_outp=&_out;
22289  octave_value _outv;
22290 
22291  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
22292  SWIG_fail;
22293  }
22294  ecode1 = SWIG_AsVal_double(args(0), &val1);
22295  if (!SWIG_IsOK(ecode1)) {
22296  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
22297  }
22298  arg1 = (PLFLT)(val1);
22299  ecode2 = SWIG_AsVal_double(args(1), &val2);
22300  if (!SWIG_IsOK(ecode2)) {
22301  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
22302  }
22303  arg2 = (PLFLT)(val2);
22304  ecode3 = SWIG_AsVal_double(args(2), &val3);
22305  if (!SWIG_IsOK(ecode3)) {
22306  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
22307  }
22308  arg3 = (PLFLT)(val3);
22309  ecode4 = SWIG_AsVal_double(args(3), &val4);
22310  if (!SWIG_IsOK(ecode4)) {
22311  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
22312  }
22313  arg4 = (PLFLT)(val4);
22314  ecode5 = SWIG_AsVal_double(args(4), &val5);
22315  if (!SWIG_IsOK(ecode5)) {
22316  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
22317  }
22318  arg5 = (PLFLT)(val5);
22319  ecode6 = SWIG_AsVal_double(args(5), &val6);
22320  if (!SWIG_IsOK(ecode6)) {
22321  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
22322  }
22323  arg6 = (PLFLT)(val6);
22324  ecode7 = SWIG_AsVal_double(args(6), &val7);
22325  if (!SWIG_IsOK(ecode7)) {
22326  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
22327  }
22328  arg7 = (PLFLT)(val7);
22329  ecode8 = SWIG_AsVal_double(args(7), &val8);
22330  if (!SWIG_IsOK(ecode8)) {
22331  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
22332  }
22333  arg8 = (PLFLT)(val8);
22334  ecode9 = SWIG_AsVal_double(args(8), &val9);
22335  if (!SWIG_IsOK(ecode9)) {
22336  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
22337  }
22338  arg9 = (PLFLT)(val9);
22339  ecode10 = SWIG_AsVal_double(args(9), &val10);
22340  if (!SWIG_IsOK(ecode10)) {
22341  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
22342  }
22343  arg10 = (PLFLT)(val10);
22344  ecode11 = SWIG_AsVal_double(args(10), &val11);
22345  if (!SWIG_IsOK(ecode11)) {
22346  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
22347  }
22348  arg11 = (PLFLT)(val11);
22349  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22350  _outv = octave_value();
22351  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22352 fail:
22353  return _out;
22354 }
22355 
22356 
22357 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
22358  PLFLT arg1 ;
22359  double val1 ;
22360  int ecode1 = 0 ;
22361  octave_value_list _out;
22362  octave_value_list *_outp=&_out;
22363  octave_value _outv;
22364 
22365  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
22366  SWIG_fail;
22367  }
22368  ecode1 = SWIG_AsVal_double(args(0), &val1);
22369  if (!SWIG_IsOK(ecode1)) {
22370  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
22371  }
22372  arg1 = (PLFLT)(val1);
22373  plwidth(arg1);
22374  _outv = octave_value();
22375  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22376 fail:
22377  return _out;
22378 }
22379 
22380 
22381 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
22382  PLFLT arg1 ;
22383  PLFLT arg2 ;
22384  PLFLT arg3 ;
22385  PLFLT arg4 ;
22386  double val1 ;
22387  int ecode1 = 0 ;
22388  double val2 ;
22389  int ecode2 = 0 ;
22390  double val3 ;
22391  int ecode3 = 0 ;
22392  double val4 ;
22393  int ecode4 = 0 ;
22394  octave_value_list _out;
22395  octave_value_list *_outp=&_out;
22396  octave_value _outv;
22397 
22398  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
22399  SWIG_fail;
22400  }
22401  ecode1 = SWIG_AsVal_double(args(0), &val1);
22402  if (!SWIG_IsOK(ecode1)) {
22403  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
22404  }
22405  arg1 = (PLFLT)(val1);
22406  ecode2 = SWIG_AsVal_double(args(1), &val2);
22407  if (!SWIG_IsOK(ecode2)) {
22408  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
22409  }
22410  arg2 = (PLFLT)(val2);
22411  ecode3 = SWIG_AsVal_double(args(2), &val3);
22412  if (!SWIG_IsOK(ecode3)) {
22413  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
22414  }
22415  arg3 = (PLFLT)(val3);
22416  ecode4 = SWIG_AsVal_double(args(3), &val4);
22417  if (!SWIG_IsOK(ecode4)) {
22418  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
22419  }
22420  arg4 = (PLFLT)(val4);
22421  plwind(arg1,arg2,arg3,arg4);
22422  _outv = octave_value();
22423  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22424 fail:
22425  return _out;
22426 }
22427 
22428 
22429 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
22430  PLBOOL arg1 ;
22431  PLBOOL *arg2 = (PLBOOL *) 0 ;
22432  int val1 ;
22433  int ecode1 = 0 ;
22434  PLBOOL temp2 ;
22435  int res2 = SWIG_TMPOBJ ;
22436  octave_value_list _out;
22437  octave_value_list *_outp=&_out;
22438  octave_value _outv;
22439 
22440  arg2 = &temp2;
22441  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
22442  SWIG_fail;
22443  }
22444  ecode1 = SWIG_AsVal_int(args(0), &val1);
22445  if (!SWIG_IsOK(ecode1)) {
22446  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
22447  }
22448  arg1 = (PLBOOL)(val1);
22449  plxormod(arg1,arg2);
22450  _outv = octave_value();
22451  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22452  if (SWIG_IsTmpObj(res2)) {
22453  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
22454  } else {
22455  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22456  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22457  }
22458 fail:
22459  return _out;
22460 }
22461 
22462 
22463 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
22464  mapform_func arg1 = (mapform_func) 0 ;
22465  char *arg2 = (char *) 0 ;
22466  PLFLT arg3 ;
22467  PLFLT arg4 ;
22468  PLFLT arg5 ;
22469  PLFLT arg6 ;
22470  int res2 ;
22471  char *buf2 = 0 ;
22472  int alloc2 = 0 ;
22473  double val3 ;
22474  int ecode3 = 0 ;
22475  double val4 ;
22476  int ecode4 = 0 ;
22477  double val5 ;
22478  int ecode5 = 0 ;
22479  double val6 ;
22480  int ecode6 = 0 ;
22481  octave_value_list _out;
22482  octave_value_list *_outp=&_out;
22483  octave_value _outv;
22484 
22485  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
22486  SWIG_fail;
22487  }
22488  {
22489  octave_value obj = args(0);
22490  if ( !obj.is_empty() )
22491  {
22492  if ( obj.is_function_handle() || obj.is_inline_function() )
22493  {
22494  fcnMapForm = obj.function_value();
22495  }
22496  else if ( obj.is_string() )
22497  {
22498  nameMapForm = obj.string_value();
22499  fcnMapForm = NULL;
22500  }
22501  arg1 = mapform_octave;
22502  }
22503  else
22504  {
22505  arg1 = NULL;
22506  }
22507  }
22508  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22509  if (!SWIG_IsOK(res2)) {
22510  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
22511  }
22512  arg2 = (char *)(buf2);
22513  ecode3 = SWIG_AsVal_double(args(2), &val3);
22514  if (!SWIG_IsOK(ecode3)) {
22515  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
22516  }
22517  arg3 = (PLFLT)(val3);
22518  ecode4 = SWIG_AsVal_double(args(3), &val4);
22519  if (!SWIG_IsOK(ecode4)) {
22520  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
22521  }
22522  arg4 = (PLFLT)(val4);
22523  ecode5 = SWIG_AsVal_double(args(4), &val5);
22524  if (!SWIG_IsOK(ecode5)) {
22525  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
22526  }
22527  arg5 = (PLFLT)(val5);
22528  ecode6 = SWIG_AsVal_double(args(5), &val6);
22529  if (!SWIG_IsOK(ecode6)) {
22530  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
22531  }
22532  arg6 = (PLFLT)(val6);
22533  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
22534  _outv = octave_value();
22535  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22536  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22537 fail:
22538  return _out;
22539 }
22540 
22541 
22542 SWIG_DEFUN( plmapline, _wrap_plmapline, _wrap_plmapline_texinfo ) {
22543  mapform_func arg1 = (mapform_func) 0 ;
22544  char *arg2 = (char *) 0 ;
22545  PLFLT arg3 ;
22546  PLFLT arg4 ;
22547  PLFLT arg5 ;
22548  PLFLT arg6 ;
22549  PLINT *arg7 = (PLINT *) 0 ;
22550  PLINT arg8 ;
22551  int res2 ;
22552  char *buf2 = 0 ;
22553  int alloc2 = 0 ;
22554  double val3 ;
22555  int ecode3 = 0 ;
22556  double val4 ;
22557  int ecode4 = 0 ;
22558  double val5 ;
22559  int ecode5 = 0 ;
22560  double val6 ;
22561  int ecode6 = 0 ;
22562  Matrix temp7 ;
22563  octave_value_list _out;
22564  octave_value_list *_outp=&_out;
22565  octave_value _outv;
22566 
22567  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
22568  SWIG_fail;
22569  }
22570  {
22571  octave_value obj = args(0);
22572  if ( !obj.is_empty() )
22573  {
22574  if ( obj.is_function_handle() || obj.is_inline_function() )
22575  {
22576  fcnMapForm = obj.function_value();
22577  }
22578  else if ( obj.is_string() )
22579  {
22580  nameMapForm = obj.string_value();
22581  fcnMapForm = NULL;
22582  }
22583  arg1 = mapform_octave;
22584  }
22585  else
22586  {
22587  arg1 = NULL;
22588  }
22589  }
22590  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22591  if (!SWIG_IsOK(res2)) {
22592  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
22593  }
22594  arg2 = (char *)(buf2);
22595  ecode3 = SWIG_AsVal_double(args(2), &val3);
22596  if (!SWIG_IsOK(ecode3)) {
22597  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
22598  }
22599  arg3 = (PLFLT)(val3);
22600  ecode4 = SWIG_AsVal_double(args(3), &val4);
22601  if (!SWIG_IsOK(ecode4)) {
22602  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
22603  }
22604  arg4 = (PLFLT)(val4);
22605  ecode5 = SWIG_AsVal_double(args(4), &val5);
22606  if (!SWIG_IsOK(ecode5)) {
22607  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
22608  }
22609  arg5 = (PLFLT)(val5);
22610  ecode6 = SWIG_AsVal_double(args(5), &val6);
22611  if (!SWIG_IsOK(ecode6)) {
22612  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
22613  }
22614  arg6 = (PLFLT)(val6);
22615  {
22616  if ( _n_dims( args(6) ) > 1 )
22617  {
22618  error( "argument must be a scalar or vector" ); SWIG_fail;
22619  }
22620  if ( !args(6).is_empty() )
22621  {
22622  arg8 = (PLINT) ( _dim( args(6), 0 ) );
22623  temp7 = args(6).matrix_value();
22624  arg7 = new PLINT[arg8];
22625  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
22626  }
22627  else
22628  {
22629  arg7 = NULL;
22630  arg8 = 0;
22631  }
22632  }
22633  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
22634  _outv = octave_value();
22635  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22636  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22637  {
22638  delete [] arg7;
22639  }
22640 fail:
22641  return _out;
22642 }
22643 
22644 
22645 SWIG_DEFUN( plmapstring, _wrap_plmapstring, _wrap_plmapstring_texinfo ) {
22646  mapform_func arg1 = (mapform_func) 0 ;
22647  char *arg2 = (char *) 0 ;
22648  char *arg3 = (char *) 0 ;
22649  PLFLT arg4 ;
22650  PLFLT arg5 ;
22651  PLFLT arg6 ;
22652  PLFLT arg7 ;
22653  PLINT *arg8 = (PLINT *) 0 ;
22654  PLINT arg9 ;
22655  int res2 ;
22656  char *buf2 = 0 ;
22657  int alloc2 = 0 ;
22658  int res3 ;
22659  char *buf3 = 0 ;
22660  int alloc3 = 0 ;
22661  double val4 ;
22662  int ecode4 = 0 ;
22663  double val5 ;
22664  int ecode5 = 0 ;
22665  double val6 ;
22666  int ecode6 = 0 ;
22667  double val7 ;
22668  int ecode7 = 0 ;
22669  Matrix temp8 ;
22670  octave_value_list _out;
22671  octave_value_list *_outp=&_out;
22672  octave_value _outv;
22673 
22674  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
22675  SWIG_fail;
22676  }
22677  {
22678  octave_value obj = args(0);
22679  if ( !obj.is_empty() )
22680  {
22681  if ( obj.is_function_handle() || obj.is_inline_function() )
22682  {
22683  fcnMapForm = obj.function_value();
22684  }
22685  else if ( obj.is_string() )
22686  {
22687  nameMapForm = obj.string_value();
22688  fcnMapForm = NULL;
22689  }
22690  arg1 = mapform_octave;
22691  }
22692  else
22693  {
22694  arg1 = NULL;
22695  }
22696  }
22697  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22698  if (!SWIG_IsOK(res2)) {
22699  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
22700  }
22701  arg2 = (char *)(buf2);
22702  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
22703  if (!SWIG_IsOK(res3)) {
22704  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
22705  }
22706  arg3 = (char *)(buf3);
22707  ecode4 = SWIG_AsVal_double(args(3), &val4);
22708  if (!SWIG_IsOK(ecode4)) {
22709  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
22710  }
22711  arg4 = (PLFLT)(val4);
22712  ecode5 = SWIG_AsVal_double(args(4), &val5);
22713  if (!SWIG_IsOK(ecode5)) {
22714  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
22715  }
22716  arg5 = (PLFLT)(val5);
22717  ecode6 = SWIG_AsVal_double(args(5), &val6);
22718  if (!SWIG_IsOK(ecode6)) {
22719  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
22720  }
22721  arg6 = (PLFLT)(val6);
22722  ecode7 = SWIG_AsVal_double(args(6), &val7);
22723  if (!SWIG_IsOK(ecode7)) {
22724  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
22725  }
22726  arg7 = (PLFLT)(val7);
22727  {
22728  if ( _n_dims( args(7) ) > 1 )
22729  {
22730  error( "argument must be a scalar or vector" ); SWIG_fail;
22731  }
22732  if ( !args(7).is_empty() )
22733  {
22734  arg9 = (PLINT) ( _dim( args(7), 0 ) );
22735  temp8 = args(7).matrix_value();
22736  arg8 = new PLINT[arg9];
22737  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
22738  }
22739  else
22740  {
22741  arg8 = NULL;
22742  arg9 = 0;
22743  }
22744  }
22745  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
22746  _outv = octave_value();
22747  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22748  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22749  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
22750  {
22751  delete [] arg8;
22752  }
22753 fail:
22754  return _out;
22755 }
22756 
22757 
22758 SWIG_DEFUN( plmaptex, _wrap_plmaptex, _wrap_plmaptex_texinfo ) {
22759  mapform_func arg1 = (mapform_func) 0 ;
22760  char *arg2 = (char *) 0 ;
22761  PLFLT arg3 ;
22762  PLFLT arg4 ;
22763  PLFLT arg5 ;
22764  char *arg6 = (char *) 0 ;
22765  PLFLT arg7 ;
22766  PLFLT arg8 ;
22767  PLFLT arg9 ;
22768  PLFLT arg10 ;
22769  PLINT arg11 ;
22770  int res2 ;
22771  char *buf2 = 0 ;
22772  int alloc2 = 0 ;
22773  double val3 ;
22774  int ecode3 = 0 ;
22775  double val4 ;
22776  int ecode4 = 0 ;
22777  double val5 ;
22778  int ecode5 = 0 ;
22779  int res6 ;
22780  char *buf6 = 0 ;
22781  int alloc6 = 0 ;
22782  double val7 ;
22783  int ecode7 = 0 ;
22784  double val8 ;
22785  int ecode8 = 0 ;
22786  double val9 ;
22787  int ecode9 = 0 ;
22788  double val10 ;
22789  int ecode10 = 0 ;
22790  int val11 ;
22791  int ecode11 = 0 ;
22792  octave_value_list _out;
22793  octave_value_list *_outp=&_out;
22794  octave_value _outv;
22795 
22796  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
22797  SWIG_fail;
22798  }
22799  {
22800  octave_value obj = args(0);
22801  if ( !obj.is_empty() )
22802  {
22803  if ( obj.is_function_handle() || obj.is_inline_function() )
22804  {
22805  fcnMapForm = obj.function_value();
22806  }
22807  else if ( obj.is_string() )
22808  {
22809  nameMapForm = obj.string_value();
22810  fcnMapForm = NULL;
22811  }
22812  arg1 = mapform_octave;
22813  }
22814  else
22815  {
22816  arg1 = NULL;
22817  }
22818  }
22819  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22820  if (!SWIG_IsOK(res2)) {
22821  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
22822  }
22823  arg2 = (char *)(buf2);
22824  ecode3 = SWIG_AsVal_double(args(2), &val3);
22825  if (!SWIG_IsOK(ecode3)) {
22826  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
22827  }
22828  arg3 = (PLFLT)(val3);
22829  ecode4 = SWIG_AsVal_double(args(3), &val4);
22830  if (!SWIG_IsOK(ecode4)) {
22831  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
22832  }
22833  arg4 = (PLFLT)(val4);
22834  ecode5 = SWIG_AsVal_double(args(4), &val5);
22835  if (!SWIG_IsOK(ecode5)) {
22836  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
22837  }
22838  arg5 = (PLFLT)(val5);
22839  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22840  if (!SWIG_IsOK(res6)) {
22841  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
22842  }
22843  arg6 = (char *)(buf6);
22844  ecode7 = SWIG_AsVal_double(args(6), &val7);
22845  if (!SWIG_IsOK(ecode7)) {
22846  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
22847  }
22848  arg7 = (PLFLT)(val7);
22849  ecode8 = SWIG_AsVal_double(args(7), &val8);
22850  if (!SWIG_IsOK(ecode8)) {
22851  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
22852  }
22853  arg8 = (PLFLT)(val8);
22854  ecode9 = SWIG_AsVal_double(args(8), &val9);
22855  if (!SWIG_IsOK(ecode9)) {
22856  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
22857  }
22858  arg9 = (PLFLT)(val9);
22859  ecode10 = SWIG_AsVal_double(args(9), &val10);
22860  if (!SWIG_IsOK(ecode10)) {
22861  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
22862  }
22863  arg10 = (PLFLT)(val10);
22864  ecode11 = SWIG_AsVal_int(args(10), &val11);
22865  if (!SWIG_IsOK(ecode11)) {
22866  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
22867  }
22868  arg11 = (PLINT)(val11);
22869  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
22870  _outv = octave_value();
22871  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22872  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22873  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22874 fail:
22875  return _out;
22876 }
22877 
22878 
22879 SWIG_DEFUN( plmapfill, _wrap_plmapfill, _wrap_plmapfill_texinfo ) {
22880  mapform_func arg1 = (mapform_func) 0 ;
22881  char *arg2 = (char *) 0 ;
22882  PLFLT arg3 ;
22883  PLFLT arg4 ;
22884  PLFLT arg5 ;
22885  PLFLT arg6 ;
22886  PLINT *arg7 = (PLINT *) 0 ;
22887  PLINT arg8 ;
22888  int res2 ;
22889  char *buf2 = 0 ;
22890  int alloc2 = 0 ;
22891  double val3 ;
22892  int ecode3 = 0 ;
22893  double val4 ;
22894  int ecode4 = 0 ;
22895  double val5 ;
22896  int ecode5 = 0 ;
22897  double val6 ;
22898  int ecode6 = 0 ;
22899  Matrix temp7 ;
22900  octave_value_list _out;
22901  octave_value_list *_outp=&_out;
22902  octave_value _outv;
22903 
22904  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
22905  SWIG_fail;
22906  }
22907  {
22908  octave_value obj = args(0);
22909  if ( !obj.is_empty() )
22910  {
22911  if ( obj.is_function_handle() || obj.is_inline_function() )
22912  {
22913  fcnMapForm = obj.function_value();
22914  }
22915  else if ( obj.is_string() )
22916  {
22917  nameMapForm = obj.string_value();
22918  fcnMapForm = NULL;
22919  }
22920  arg1 = mapform_octave;
22921  }
22922  else
22923  {
22924  arg1 = NULL;
22925  }
22926  }
22927  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22928  if (!SWIG_IsOK(res2)) {
22929  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
22930  }
22931  arg2 = (char *)(buf2);
22932  ecode3 = SWIG_AsVal_double(args(2), &val3);
22933  if (!SWIG_IsOK(ecode3)) {
22934  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
22935  }
22936  arg3 = (PLFLT)(val3);
22937  ecode4 = SWIG_AsVal_double(args(3), &val4);
22938  if (!SWIG_IsOK(ecode4)) {
22939  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
22940  }
22941  arg4 = (PLFLT)(val4);
22942  ecode5 = SWIG_AsVal_double(args(4), &val5);
22943  if (!SWIG_IsOK(ecode5)) {
22944  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
22945  }
22946  arg5 = (PLFLT)(val5);
22947  ecode6 = SWIG_AsVal_double(args(5), &val6);
22948  if (!SWIG_IsOK(ecode6)) {
22949  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
22950  }
22951  arg6 = (PLFLT)(val6);
22952  {
22953  if ( _n_dims( args(6) ) > 1 )
22954  {
22955  error( "argument must be a scalar or vector" ); SWIG_fail;
22956  }
22957  if ( !args(6).is_empty() )
22958  {
22959  arg8 = (PLINT) ( _dim( args(6), 0 ) );
22960  temp7 = args(6).matrix_value();
22961  arg7 = new PLINT[arg8];
22962  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
22963  }
22964  else
22965  {
22966  arg7 = NULL;
22967  arg8 = 0;
22968  }
22969  }
22970  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
22971  _outv = octave_value();
22972  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22973  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22974  {
22975  delete [] arg7;
22976  }
22977 fail:
22978  return _out;
22979 }
22980 
22981 
22982 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
22983  mapform_func arg1 = (mapform_func) 0 ;
22984  PLFLT arg2 ;
22985  PLFLT arg3 ;
22986  PLFLT arg4 ;
22987  PLFLT arg5 ;
22988  PLFLT arg6 ;
22989  PLFLT arg7 ;
22990  double val2 ;
22991  int ecode2 = 0 ;
22992  double val3 ;
22993  int ecode3 = 0 ;
22994  double val4 ;
22995  int ecode4 = 0 ;
22996  double val5 ;
22997  int ecode5 = 0 ;
22998  double val6 ;
22999  int ecode6 = 0 ;
23000  double val7 ;
23001  int ecode7 = 0 ;
23002  octave_value_list _out;
23003  octave_value_list *_outp=&_out;
23004  octave_value _outv;
23005 
23006  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
23007  SWIG_fail;
23008  }
23009  {
23010  octave_value obj = args(0);
23011  if ( !obj.is_empty() )
23012  {
23013  if ( obj.is_function_handle() || obj.is_inline_function() )
23014  {
23015  fcnMapForm = obj.function_value();
23016  }
23017  else if ( obj.is_string() )
23018  {
23019  nameMapForm = obj.string_value();
23020  fcnMapForm = NULL;
23021  }
23022  arg1 = mapform_octave;
23023  }
23024  else
23025  {
23026  arg1 = NULL;
23027  }
23028  }
23029  ecode2 = SWIG_AsVal_double(args(1), &val2);
23030  if (!SWIG_IsOK(ecode2)) {
23031  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
23032  }
23033  arg2 = (PLFLT)(val2);
23034  ecode3 = SWIG_AsVal_double(args(2), &val3);
23035  if (!SWIG_IsOK(ecode3)) {
23036  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
23037  }
23038  arg3 = (PLFLT)(val3);
23039  ecode4 = SWIG_AsVal_double(args(3), &val4);
23040  if (!SWIG_IsOK(ecode4)) {
23041  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
23042  }
23043  arg4 = (PLFLT)(val4);
23044  ecode5 = SWIG_AsVal_double(args(4), &val5);
23045  if (!SWIG_IsOK(ecode5)) {
23046  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
23047  }
23048  arg5 = (PLFLT)(val5);
23049  ecode6 = SWIG_AsVal_double(args(5), &val6);
23050  if (!SWIG_IsOK(ecode6)) {
23051  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
23052  }
23053  arg6 = (PLFLT)(val6);
23054  ecode7 = SWIG_AsVal_double(args(6), &val7);
23055  if (!SWIG_IsOK(ecode7)) {
23056  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
23057  }
23058  arg7 = (PLFLT)(val7);
23059  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23060  _outv = octave_value();
23061  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23062 fail:
23063  return _out;
23064 }
23065 
23066 
23068  octave_value_list _out;
23069  octave_value_list *_outp=&_out;
23070  octave_value _outv;
23071 
23072  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
23073  SWIG_fail;
23074  }
23075  plClearOpts();
23076  _outv = octave_value();
23077  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23078 fail:
23079  return _out;
23080 }
23081 
23082 
23084  octave_value_list _out;
23085  octave_value_list *_outp=&_out;
23086  octave_value _outv;
23087 
23088  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
23089  SWIG_fail;
23090  }
23091  plResetOpts();
23092  _outv = octave_value();
23093  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23094 fail:
23095  return _out;
23096 }
23097 
23098 
23100  char *arg1 = (char *) 0 ;
23101  char *arg2 = (char *) 0 ;
23102  int res1 ;
23103  char *buf1 = 0 ;
23104  int alloc1 = 0 ;
23105  int res2 ;
23106  char *buf2 = 0 ;
23107  int alloc2 = 0 ;
23108  octave_value_list _out;
23109  octave_value_list *_outp=&_out;
23110  octave_value _outv;
23111 
23112  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
23113  SWIG_fail;
23114  }
23115  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23116  if (!SWIG_IsOK(res1)) {
23117  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
23118  }
23119  arg1 = (char *)(buf1);
23120  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23121  if (!SWIG_IsOK(res2)) {
23122  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
23123  }
23124  arg2 = (char *)(buf2);
23125  plSetUsage((char const *)arg1,(char const *)arg2);
23126  _outv = octave_value();
23127  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23128  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23129  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23130 fail:
23131  return _out;
23132 }
23133 
23134 
23136  octave_value_list _out;
23137  octave_value_list *_outp=&_out;
23138  octave_value _outv;
23139 
23140  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
23141  SWIG_fail;
23142  }
23143  plOptUsage();
23144  _outv = octave_value();
23145  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23146 fail:
23147  return _out;
23148 }
23149 
23150 
23151 
23152 static const struct swig_octave_member swig_globals[] = {
23153 {"testppchar",_wrap_testppchar,0,0,2,0},
23154 {"plGetCursor",_wrap_plGetCursor,0,0,2,0},
23155 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
23156 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
23157 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
23158 {"plcont0",_wrap_plcont0,0,0,2,0},
23159 {"plcont1",_wrap_plcont1,0,0,2,0},
23160 {"plcont2",_wrap_plcont2,0,0,2,0},
23161 {"plcont2p",_wrap_plcont2p,0,0,2,0},
23162 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
23163 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
23164 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
23165 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
23166 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
23167 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
23168 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
23169 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
23170 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
23171 {"plshade1",_wrap_plshade1,0,0,2,_wrap_plshade1_texinfo},
23172 {"plshade2",_wrap_plshade2,0,0,2,0},
23173 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
23174 {"plshadesx",_wrap_plshadesx,0,0,2,0},
23175 {"plshades1",_wrap_plshades1,0,0,2,0},
23176 {"plshades2",_wrap_plshades2,0,0,2,0},
23177 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
23178 {"plvect1",_wrap_plvect1,0,0,2,0},
23179 {"plvect2",_wrap_plvect2,0,0,2,0},
23180 {"pplimage",_wrap_pplimage,0,0,2,0},
23181 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
23182 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
23183 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
23184 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
23185 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
23186 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
23187 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
23188 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
23189 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
23190 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
23191 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
23192 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
23193 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
23194 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
23195 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
23196 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
23197 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
23198 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
23199 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
23200 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
23201 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
23202 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
23203 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
23204 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
23205 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
23206 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
23207 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
23208 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
23209 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
23210 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
23211 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
23212 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
23213 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
23214 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
23215 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
23216 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
23217 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
23218 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
23219 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
23220 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
23221 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
23222 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
23223 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
23224 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
23225 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
23226 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
23227 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
23228 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
23229 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
23230 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
23231 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
23232 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
23233 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
23234 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
23235 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
23236 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
23237 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
23238 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
23239 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
23240 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
23241 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
23242 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
23243 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
23244 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
23245 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
23246 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
23247 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
23248 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
23249 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
23250 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
23251 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
23252 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
23253 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
23254 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
23255 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
23256 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
23257 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
23258 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
23259 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
23260 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
23261 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
23262 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
23263 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
23264 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
23265 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
23266 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
23267 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
23268 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
23269 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
23270 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
23271 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
23272 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
23273 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
23274 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
23275 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
23276 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
23277 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
23278 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
23279 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
23280 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
23281 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
23282 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
23283 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
23284 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
23285 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
23286 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
23287 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
23288 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
23289 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
23290 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
23291 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
23292 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
23293 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
23294 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
23295 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
23296 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
23297 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
23298 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
23299 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
23300 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
23301 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
23302 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
23303 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
23304 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
23305 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
23306 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
23307 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
23308 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
23309 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
23310 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
23311 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
23312 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
23313 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
23314 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
23315 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
23316 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
23317 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
23318 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
23319 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
23320 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
23321 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
23322 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
23323 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
23324 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
23325 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
23326 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
23327 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
23328 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
23329 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
23330 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
23331 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
23332 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
23333 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
23334 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
23335 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
23336 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
23337 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
23338 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
23339 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
23340 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
23341 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
23342 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
23343 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
23344 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
23345 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
23346 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
23347 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
23348 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
23349 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
23350 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
23351 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
23352 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
23353 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
23354 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
23355 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
23356 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
23357 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
23358 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
23359 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
23360 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
23361 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
23362 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
23363 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
23364 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
23365 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
23366 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
23367 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
23368 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
23369 {0,0,0,0,0}
23370 };
23371 
23372 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
23373 
23374 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
23375 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
23376 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
23377 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|void (*)(double,double,double *,double *,void *)", 0, 0, (void*)0, 0};
23378 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};
23379 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};
23380 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
23381 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
23382 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
23383 
23386  &_swigt__p_char,
23391  &_swigt__p_int,
23394 };
23395 
23396 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23397 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23398 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23402 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23403 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23404 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23405 
23413  _swigc__p_int,
23416 };
23417 
23418 
23419 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23420 
23421 /* -----------------------------------------------------------------------------
23422  * Type initialization:
23423  * This problem is tough by the requirement that no dynamic
23424  * memory is used. Also, since swig_type_info structures store pointers to
23425  * swig_cast_info structures and swig_cast_info structures store pointers back
23426  * to swig_type_info structures, we need some lookup code at initialization.
23427  * The idea is that swig generates all the structures that are needed.
23428  * The runtime then collects these partially filled structures.
23429  * The SWIG_InitializeModule function takes these initial arrays out of
23430  * swig_module, and does all the lookup, filling in the swig_module.types
23431  * array with the correct data and linking the correct swig_cast_info
23432  * structures together.
23433  *
23434  * The generated swig_type_info structures are assigned staticly to an initial
23435  * array. We just loop through that array, and handle each type individually.
23436  * First we lookup if this type has been already loaded, and if so, use the
23437  * loaded structure instead of the generated one. Then we have to fill in the
23438  * cast linked list. The cast data is initially stored in something like a
23439  * two-dimensional array. Each row corresponds to a type (there are the same
23440  * number of rows as there are in the swig_type_initial array). Each entry in
23441  * a column is one of the swig_cast_info structures for that type.
23442  * The cast_initial array is actually an array of arrays, because each row has
23443  * a variable number of columns. So to actually build the cast linked list,
23444  * we find the array of casts associated with the type, and loop through it
23445  * adding the casts to the list. The one last trick we need to do is making
23446  * sure the type pointer in the swig_cast_info struct is correct.
23447  *
23448  * First off, we lookup the cast->type name to see if it is already loaded.
23449  * There are three cases to handle:
23450  * 1) If the cast->type has already been loaded AND the type we are adding
23451  * casting info to has not been loaded (it is in this module), THEN we
23452  * replace the cast->type pointer with the type pointer that has already
23453  * been loaded.
23454  * 2) If BOTH types (the one we are adding casting info to, and the
23455  * cast->type) are loaded, THEN the cast info has already been loaded by
23456  * the previous module so we just ignore it.
23457  * 3) Finally, if cast->type has not already been loaded, then we add that
23458  * swig_cast_info to the linked list (because the cast->type) pointer will
23459  * be correct.
23460  * ----------------------------------------------------------------------------- */
23461 
23462 #ifdef __cplusplus
23463 extern "C" {
23464 #if 0
23465 } /* c-mode */
23466 #endif
23467 #endif
23468 
23469 #if 0
23470 #define SWIGRUNTIME_DEBUG
23471 #endif
23472 
23473 
23474 SWIGRUNTIME void
23475 SWIG_InitializeModule(void *clientdata) {
23476  size_t i;
23477  swig_module_info *module_head, *iter;
23478  int found, init;
23479 
23480  clientdata = clientdata;
23481 
23482  /* check to see if the circular list has been setup, if not, set it up */
23483  if (swig_module.next==0) {
23484  /* Initialize the swig_module */
23485  swig_module.type_initial = swig_type_initial;
23486  swig_module.cast_initial = swig_cast_initial;
23487  swig_module.next = &swig_module;
23488  init = 1;
23489  } else {
23490  init = 0;
23491  }
23492 
23493  /* Try and load any already created modules */
23494  module_head = SWIG_GetModule(clientdata);
23495  if (!module_head) {
23496  /* This is the first module loaded for this interpreter */
23497  /* so set the swig module into the interpreter */
23498  SWIG_SetModule(clientdata, &swig_module);
23499  module_head = &swig_module;
23500  } else {
23501  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23502  found=0;
23503  iter=module_head;
23504  do {
23505  if (iter==&swig_module) {
23506  found=1;
23507  break;
23508  }
23509  iter=iter->next;
23510  } while (iter!= module_head);
23511 
23512  /* if the is found in the list, then all is done and we may leave */
23513  if (found) return;
23514  /* otherwise we must add out module into the list */
23515  swig_module.next = module_head->next;
23516  module_head->next = &swig_module;
23517  }
23518 
23519  /* When multiple interpeters are used, a module could have already been initialized in
23520  a different interpreter, but not yet have a pointer in this interpreter.
23521  In this case, we do not want to continue adding types... everything should be
23522  set up already */
23523  if (init == 0) return;
23524 
23525  /* Now work on filling in swig_module.types */
23526 #ifdef SWIGRUNTIME_DEBUG
23527  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23528 #endif
23529  for (i = 0; i < swig_module.size; ++i) {
23530  swig_type_info *type = 0;
23531  swig_type_info *ret;
23532  swig_cast_info *cast;
23533 
23534 #ifdef SWIGRUNTIME_DEBUG
23535  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23536 #endif
23537 
23538  /* if there is another module already loaded */
23539  if (swig_module.next != &swig_module) {
23540  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23541  }
23542  if (type) {
23543  /* Overwrite clientdata field */
23544 #ifdef SWIGRUNTIME_DEBUG
23545  printf("SWIG_InitializeModule: found type %s\n", type->name);
23546 #endif
23547  if (swig_module.type_initial[i]->clientdata) {
23548  type->clientdata = swig_module.type_initial[i]->clientdata;
23549 #ifdef SWIGRUNTIME_DEBUG
23550  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23551 #endif
23552  }
23553  } else {
23554  type = swig_module.type_initial[i];
23555  }
23556 
23557  /* Insert casting types */
23558  cast = swig_module.cast_initial[i];
23559  while (cast->type) {
23560 
23561  /* Don't need to add information already in the list */
23562  ret = 0;
23563 #ifdef SWIGRUNTIME_DEBUG
23564  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23565 #endif
23566  if (swig_module.next != &swig_module) {
23567  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23568 #ifdef SWIGRUNTIME_DEBUG
23569  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23570 #endif
23571  }
23572  if (ret) {
23573  if (type == swig_module.type_initial[i]) {
23574 #ifdef SWIGRUNTIME_DEBUG
23575  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23576 #endif
23577  cast->type = ret;
23578  ret = 0;
23579  } else {
23580  /* Check for casting already in the list */
23581  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23582 #ifdef SWIGRUNTIME_DEBUG
23583  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23584 #endif
23585  if (!ocast) ret = 0;
23586  }
23587  }
23588 
23589  if (!ret) {
23590 #ifdef SWIGRUNTIME_DEBUG
23591  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23592 #endif
23593  if (type->cast) {
23594  type->cast->prev = cast;
23595  cast->next = type->cast;
23596  }
23597  type->cast = cast;
23598  }
23599  cast++;
23600  }
23601  /* Set entry in modules->types array equal to the type */
23602  swig_module.types[i] = type;
23603  }
23604  swig_module.types[i] = 0;
23605 
23606 #ifdef SWIGRUNTIME_DEBUG
23607  printf("**** SWIG_InitializeModule: Cast List ******\n");
23608  for (i = 0; i < swig_module.size; ++i) {
23609  int j = 0;
23610  swig_cast_info *cast = swig_module.cast_initial[i];
23611  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23612  while (cast->type) {
23613  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23614  cast++;
23615  ++j;
23616  }
23617  printf("---- Total casts: %d\n",j);
23618  }
23619  printf("**** SWIG_InitializeModule: Cast List ******\n");
23620 #endif
23621 }
23622 
23623 /* This function will propagate the clientdata field of type to
23624 * any new swig_type_info structures that have been added into the list
23625 * of equivalent types. It is like calling
23626 * SWIG_TypeClientData(type, clientdata) a second time.
23627 */
23628 SWIGRUNTIME void
23630  size_t i;
23631  swig_cast_info *equiv;
23632  static int init_run = 0;
23633 
23634  if (init_run) return;
23635  init_run = 1;
23636 
23637  for (i = 0; i < swig_module.size; i++) {
23638  if (swig_module.types[i]->clientdata) {
23639  equiv = swig_module.types[i]->cast;
23640  while (equiv) {
23641  if (!equiv->converter) {
23642  if (equiv->type && !equiv->type->clientdata)
23643  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23644  }
23645  equiv = equiv->next;
23646  }
23647  }
23648  }
23649 }
23650 
23651 #ifdef __cplusplus
23652 #if 0
23653 { /* c-mode */
23654 #endif
23655 }
23656 #endif
23657 
23658 
23659 
23660 static void SWIG_init_user(octave_swig_type* module_ns);
23661 
23662 SWIGINTERN void SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
23663  octave_value_list args;
23664  args.append(name);
23665  args.append(octloadfcn->fcn_file_name());
23666  feval("autoload", args, 0);
23667 }
23668 
23669 static const char *const subclass_usage = "-*- texinfo -*- \n\
23670 @deftypefn {Loadable Function} {} subclass()\n\
23671 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
23672 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
23673 \n\
23674 See the SWIG manual for usage examples.\n\
23675 @end deftypefn";
23676 
23677 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
23679  for (int j = 0; j < args.length(); ++j) {
23680  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
23681  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
23682  octave_swig_type *ost = osr->get_ptr();
23683  if (!ost->is_owned()) {
23684  error("cannot subclass object not constructed on octave side");
23685  return octave_value_list();
23686  }
23687  top->merge(*ost);
23688  } else if (args(j).is_function_handle()) {
23689  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
23690  } else if (args(j).is_string()) {
23691  if (j + 1 >= args.length()) {
23692  error("member assignments must be of string,value form");
23693  return octave_value_list();
23694  }
23695  top->assign(args(j).string_value(), args(j + 1));
23696  ++j;
23697  } else {
23698  error("invalid arguments to subclass()");
23699  return octave_value_list();
23700  }
23701  }
23702  return octave_value(Swig::swig_value_ref(top));
23703 }
23704 
23705 static const char *const swig_type_usage = "-*- texinfo -*- \n\
23706 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
23707 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
23708 @end deftypefn";
23709 
23710 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
23711  if (args.length() != 1) {
23712  error("swig_type() must be called with only a single object");
23713  return octave_value_list();
23714  }
23715  octave_swig_type *ost = Swig::swig_value_deref(args(0));
23716  if (!ost) {
23717  error("object is not a swig_ref");
23718  return octave_value_list();
23719  }
23720  return octave_value(ost->swig_type_name());
23721 }
23722 
23723 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
23724 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
23725 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
23726 otherwise return `<unknown>'.\n\
23727 @end deftypefn";
23728 
23729 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
23730  if (args.length() != 1 || !args(0).is_string()) {
23731  error("swig_typequery() must be called with single string argument");
23732  return octave_value_list();
23733  }
23734  swig_module_info *module = SWIG_GetModule(0);
23735  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
23736  if (!type)
23737  return octave_value("<unknown>");
23738  return octave_value(type->name);
23739 }
23740 
23741 static const char *const swig_this_usage = "-*- texinfo -*- \n\
23742 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
23743 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
23744 @end deftypefn";
23745 
23746 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
23747  if (args.length() != 1) {
23748  error("swig_this() must be called with only a single object");
23749  return octave_value_list();
23750  }
23751  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
23752  return octave_value(octave_uint64(0));
23753  octave_swig_type *ost = Swig::swig_value_deref(args(0));
23754  if (!ost) {
23755  error("object is not a swig_ref");
23756  return octave_value_list();
23757  }
23758  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
23759 }
23760 
23761 // workaround to prevent octave seg-faulting on exit: register at-exit
23762 // function which exits octave immediately without trying to cleanup memory.
23763 // definitely affects version 3.2.*, not sure about 3.3.*, seems to be
23764 // fixed in version 3.4.* and above. can be turned on/off with macros.
23765 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
23766 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
23767 #define SWIG_OCTAVE_SEGFAULT_HACK
23768 #endif
23769 #endif
23770 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23771 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
23772 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
23774  _exit(exit_status);
23775 }
23776 #endif
23777 
23778 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
23779 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
23780 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
23781 \n\
23782 To load the module into the global namespace:\n\
23783 @example\n\
23784 " SWIG_name_d ";\n\
23785 @end example\n\
23786 To access the module through a local variable, without loading it globally:\n\
23787 @example\n\
23788 " SWIG_name_d " = " SWIG_name_d ";\n\
23789 @end example\n\
23790 To access the module locally through a variable named, e.g. @var{modl}:\n\
23791 @example\n\
23792 @var{modl} = " SWIG_name_d ";\n\
23793 @end example\n\
23794 @end deftypefn";
23795 
23796 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
23797 
23798  static octave_swig_type* module_ns = 0;
23799  octave_value_list retval;
23800 
23801  // create module on first function call
23802  if (!module_ns) {
23803 
23804 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23806 #endif
23807 
23808  // workaround bug in octave where installing global variable of custom type and then
23809  // exiting without explicitly clearing the variable causes octave to segfault.
23810 #if OCTAVE_API_VERSION_NUMBER >= 37
23811  octave_value_list eval_args;
23812  eval_args.append("base");
23813  eval_args.append("function __swig_atexit__; "
23814  " if mislocked() "
23815  " clear -all; "
23816  " else "
23817  " mlock(); "
23818  " endif; "
23819  "endfunction; "
23820  "__swig_atexit__; "
23821  "atexit(\"__swig_atexit__\", false); "
23822  "atexit(\"__swig_atexit__\")");
23823  feval("evalin", eval_args, 0);
23824 #endif
23825 
23826  octave_swig_ref::register_type();
23827  octave_swig_packed::register_type();
23830 
23831  octave_function *me = octave_call_stack::current();
23832 
23833  SWIG_Octave_InstallFunction(me, "swig_type");
23834  SWIG_Octave_InstallFunction(me, "swig_typequery");
23835  SWIG_Octave_InstallFunction(me, "swig_this");
23836  SWIG_Octave_InstallFunction(me, "subclass");
23837 
23838  octave_swig_type* cvar_ns=0;
23839  if (std::string(SWIG_global_name) != ".") {
23840  cvar_ns=new octave_swig_type;
23841  for (int j=0;swig_globals[j].name;++j)
23842  if (swig_globals[j].get_method)
23843  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
23844  }
23845 
23846  module_ns=new octave_swig_type(0, 0, 0, true);
23847  if (std::string(SWIG_global_name) != ".") {
23848  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
23849  }
23850  else {
23851  for (int j=0;swig_globals[j].name;++j)
23852  if (swig_globals[j].get_method)
23853  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
23854  }
23855  for (int j=0;swig_globals[j].name;++j)
23856  if (swig_globals[j].method)
23857  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
23858 
23859  // * need better solution here; swig_type -> octave_class mapping is
23860  // * really n-to-1, in some cases such as template partial spec, etc.
23861  // * see failing tests.
23862  for (int j=0;swig_types[j];++j)
23863  if (swig_types[j]->clientdata) {
23864  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
23865  module_ns->assign(c->name,
23867  (new octave_swig_type(0,swig_types[j])));
23868  }
23869 
23870  SWIG_init_user(module_ns);
23871 
23872  SWIG_InstallOps(octave_swig_ref::static_type_id());
23873 
23874 #if OCTAVE_API_VERSION_NUMBER < 37
23875  mlock(me->name());
23876 #else
23877  mlock();
23878 #endif
23879 
23880  }
23881 
23882  // return module if asked for
23883  if (args.length() == 0 && nargout == 1) {
23884  retval = octave_value(module_ns->as_value());
23885  }
23886 
23887  // if call with not output arguments, load globally
23888  else if (args.length() == 0 && nargout == 0) {
23889 
23890  octave_function *me = octave_call_stack::current();
23891 
23893  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
23894  if (mb->second.first && mb->second.first->method) {
23895  SWIG_Octave_InstallFunction(me, mb->first);
23896  }
23897  else if (mb->second.second.is_defined()) {
23898  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
23899  SWIG_Octave_LinkGlobalValue(mb->first);
23900  }
23901  }
23902 
23903  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
23904  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
23905 
23906  }
23907 
23908  // otherwise print usage
23909  else {
23910  print_usage();
23911  }
23912 
23913  return retval;
23914 
23915 }
23916 
23917 
23918 static void SWIG_init_user(octave_swig_type* module_ns)
23919 {
23920  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
23921  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23922  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
23923  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
23924  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
23925  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
23926  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
23927  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
23928  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
23929  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
23930  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
23931  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
23932  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
23933  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
23934  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23935  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
23936  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23937  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
23938  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
23939  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23940  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
23941  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23942  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23943  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23944  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int((int)(25)));
23945  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int((int)(26)));
23946  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23947  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23948  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23949  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23950  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int((int)(31)));
23951  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23952  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23953  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int((int)(34)));
23954  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int((int)(35)));
23955  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int((int)(36)));
23956  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int((int)(37)));
23957  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23958  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23959  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23960  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23961  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23962  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23963  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23964  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23965  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int((int)(1)));
23966  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int((int)(2)));
23967  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int((int)(3)));
23968  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int((int)(4)));
23969  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23970  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
23971  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
23972  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
23973  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
23974  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23975  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23976  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23977  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23978  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23979  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23980  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23981  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23982  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23983  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23984  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23985  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23986  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23987  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23988  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23989  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23990  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23991  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23992  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23993  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23994  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23995  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23996  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23997  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23998  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23999  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
24000  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
24001  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
24002  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
24003  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
24004  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
24005  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
24006  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
24007  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
24008  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
24009  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
24010  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
24011  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
24012  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
24013  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
24014  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
24015  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
24016  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
24017  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
24018  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
24019  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
24020  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
24021  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
24022  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
24023  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
24024  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
24025  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
24026  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
24027  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
24028  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
24029  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
24030  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
24031  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
24032  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
24033  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
24034  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
24035  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
24036  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
24037  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
24038  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
24039  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
24040  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
24041  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
24042  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
24043  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
24044  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
24045  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
24046  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
24047  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
24048  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
24049  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
24050  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
24051  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
24052  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
24053  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
24054  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
24055  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
24056  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
24057  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
24058  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
24059  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
24060  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
24061  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
24062  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
24063  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
24064  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
24065  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
24066  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
24067  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
24068  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
24069  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x001)));
24070  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x002)));
24071  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x003)));
24072  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x004)));
24073  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x008)));
24074  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x010)));
24075  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x020)));
24076  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x040)));
24077  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x080)));
24078  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
24079 }
24080