PLplot  5.11.1
 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  d: Plot labels as date / time. Values are assumed to be\n\
8158  seconds since the epoch (as used by gmtime). \n\
8159  f: Always use fixed point numeric labels. \n\
8160  i: Inverts tick marks, so they are drawn downwards, rather\n\
8161  than upwards. \n\
8162  l: Labels axis logarithmically. This only affects the labels,\n\
8163  not the data, and so it is necessary to compute the logarithms\n\
8164  of data points before passing them to any of the drawing\n\
8165  routines. \n\
8166  n: Writes numeric labels at major tick intervals. \n\
8167  o: Use custom labelling function to generate axis label text. \n\
8168  The custom labelling function can be defined with the\n\
8169  plslabelfunc command. \n\
8170  s: Enables subticks between major ticks, only valid if t is\n\
8171  also specified. \n\
8172  t: Draws major ticks. \n\
8173  u: If this is specified, the text label for the axis is\n\
8174  written under the axis. \n\
8175 \n\
8176 \n\
8177  xlabel (const char *, input) : Pointer to character string\n\
8178  specifying text label for the x axis. It is only drawn if u is in\n\
8179  the xopt string. \n\
8180 \n\
8181  xtick (PLFLT, input) : World coordinate interval between major\n\
8182  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8183  generates a suitable tick interval. \n\
8184 \n\
8185  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8186  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8187  generates a suitable minor tick interval. \n\
8188 \n\
8189  yopt (const char *, input) : Pointer to character string specifying\n\
8190  options for the y axis. The string is interpreted in the same way\n\
8191  as xopt. \n\
8192 \n\
8193  ylabel (const char *, input) : Pointer to character string\n\
8194  specifying text label for the y axis. It is only drawn if u is in\n\
8195  the yopt string. \n\
8196 \n\
8197  ytick (PLFLT, input) : World coordinate interval between major\n\
8198  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8199  generates a suitable tick interval. \n\
8200 \n\
8201  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8202  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8203  generates a suitable minor tick interval. \n\
8204 \n\
8205  zopt (const char *, input) : Pointer to character string specifying\n\
8206  options for the z axis. The string can include any combination of\n\
8207  the following letters (upper or lower case) in any order: b: Draws\n\
8208  z axis to the left of the surface plot. \n\
8209  c: Draws z axis to the right of the surface plot. \n\
8210  d: Draws grid lines parallel to the x-y plane behind the\n\
8211  figure. These lines are not drawn until after plot3d or\n\
8212  plmesh are called because of the need for hidden line removal. \n\
8213  e: Plot labels as date / time. Values are assumed to be\n\
8214  seconds since the epoch (as used by gmtime). Note this\n\
8215  suboption is interpreted the same as the d suboption for xopt\n\
8216  and yopt, but it has to be identified as e for zopt since d\n\
8217  has already been used for the different purpose above. \n\
8218  f: Always use fixed point numeric labels. \n\
8219  i: Inverts tick marks, so they are drawn away from the center. \n\
8220  l: Labels axis logarithmically. This only affects the labels,\n\
8221  not the data, and so it is necessary to compute the logarithms\n\
8222  of data points before passing them to any of the drawing\n\
8223  routines. \n\
8224  m: Writes numeric labels at major tick intervals on the\n\
8225  right-hand vertical axis. \n\
8226  n: Writes numeric labels at major tick intervals on the\n\
8227  left-hand vertical axis. \n\
8228  o: Use custom labelling function to generate axis label text. \n\
8229  The custom labelling function can be defined with the\n\
8230  plslabelfunc command. \n\
8231  s: Enables subticks between major ticks, only valid if t is\n\
8232  also specified. \n\
8233  t: Draws major ticks. \n\
8234  u: If this is specified, the text label is written beside the\n\
8235  left-hand axis. \n\
8236  v: If this is specified, the text label is written beside the\n\
8237  right-hand axis. \n\
8238 \n\
8239 \n\
8240  zlabel (const char *, input) : Pointer to character string\n\
8241  specifying text label for the z axis. It is only drawn if u or v\n\
8242  are in the zopt string. \n\
8243 \n\
8244  ztick (PLFLT, input) : World coordinate interval between major\n\
8245  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8246  generates a suitable tick interval. \n\
8247 \n\
8248  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8249  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8250  generates a suitable minor tick interval. \n\
8251 ";
8252 const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8253 Get character default height and current (scaled) height \n\
8254 \n\
8255 DESCRIPTION:\n\
8256 \n\
8257  Get character default height and current (scaled) height. \n\
8258 \n\
8259  Redacted form: plgchr(p_def, p_ht)\n\
8260 \n\
8261  This function is used in example 23. \n\
8262 \n\
8263 \n\
8264 \n\
8265 SYNOPSIS:\n\
8266 \n\
8267 plgchr(p_def, p_ht)\n\
8268 \n\
8269 ARGUMENTS:\n\
8270 \n\
8271  p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
8272 \n\
8273  p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
8274  height (mm). \n\
8275 ";
8276 const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8277 Set the escape character for text strings \n\
8278 \n\
8279 DESCRIPTION:\n\
8280 \n\
8281  Set the escape character for text strings.\tFrom C (in contrast to\n\
8282  Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8283  selected characters are allowed to prevent the user from shooting\n\
8284  himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8285  with C\'s use of backslash as a character escape). Here are the\n\
8286  allowed escape characters and their corresponding decimal ASCII\n\
8287  values: !, ASCII 33 \n\
8288 \t #, ASCII 35 \n\
8289 \t $, ASCII 36 \n\
8290 \t %, ASCII 37 \n\
8291 \t &, ASCII 38 \n\
8292 \t *, ASCII 42 \n\
8293 \t @, ASCII 64 \n\
8294 \t ^, ASCII 94 \n\
8295 \t ~, ASCII 126 \n\
8296 \n\
8297 \n\
8298  Redacted form: General: plsesc(esc)\n\
8299 \t Perl/PDL: Not available? \n\
8300 \n\
8301 \n\
8302  This function is used in example 29. \n\
8303 \n\
8304 \n\
8305 \n\
8306 SYNOPSIS:\n\
8307 \n\
8308 plsesc(esc)\n\
8309 \n\
8310 ARGUMENTS:\n\
8311 \n\
8312  esc (char, input) : Escape character. \n\
8313 ";
8314 const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8315 Draw a line between two points, accounting for coordinate transforms \n\
8316 \n\
8317 DESCRIPTION:\n\
8318 \n\
8319  Joins the point (\n\
8320  x1, \n\
8321  y1) to (\n\
8322  x2, \n\
8323  y2) . If a global coordinate transform is defined then the line is\n\
8324  broken in to n segments to approximate the path. If no transform is\n\
8325  defined then this simply acts like a call to pljoin. \n\
8326 \n\
8327  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8328 \n\
8329  This function is used in example 22. \n\
8330 \n\
8331 \n\
8332 \n\
8333 SYNOPSIS:\n\
8334 \n\
8335 plpath(n, x1, y1, x2, y2)\n\
8336 \n\
8337 ARGUMENTS:\n\
8338 \n\
8339  n (PLINT, input) : number of points to use to approximate the path. \n\
8340 \n\
8341  x1 (PLFLT, input) : x coordinate of first point. \n\
8342 \n\
8343  y1 (PLFLT, input) : y coordinate of first point. \n\
8344 \n\
8345  x2 (PLFLT, input) : x coordinate of second point. \n\
8346 \n\
8347  y2 (PLFLT, input) : y coordinate of second point. \n\
8348 ";
8349 const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8350 Set up standard window and draw box \n\
8351 \n\
8352 DESCRIPTION:\n\
8353 \n\
8354  Sets up plotter environment for simple graphs by calling pladv and\n\
8355  setting up viewport and window to sensible default values.\tplenv\n\
8356  leaves enough room around most graphs for axis labels and a title.\n\
8357  When these defaults are not suitable, use the individual routines\n\
8358  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
8359  defining the window, and plbox for drawing the box. \n\
8360 \n\
8361  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8362 \n\
8363  This function is used in example 1,3,9,13,14,19-22,29. \n\
8364 \n\
8365 \n\
8366 \n\
8367 SYNOPSIS:\n\
8368 \n\
8369 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8370 \n\
8371 ARGUMENTS:\n\
8372 \n\
8373  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8374  world coordinates). \n\
8375 \n\
8376  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8377  world coordinates). \n\
8378 \n\
8379  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8380  coordinates). \n\
8381 \n\
8382  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8383  coordinates). \n\
8384 \n\
8385  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8386  scales will not be set, the user must set up the scale before\n\
8387  calling plenv using plsvpa, plvasp or other. \n\
8388  0: the x and y axes are scaled independently to use as much of\n\
8389  the screen as possible. \n\
8390  1: the scales of the x and y axes are made equal. \n\
8391  2: the axis of the x and y axes are made equal, and the plot\n\
8392  box will be square. \n\
8393 \n\
8394 \n\
8395  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8396  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
8397  -1: draw box only. \n\
8398  0: draw box, ticks, and numeric tick labels. \n\
8399  1: also draw coordinate axes at x=0 and y=0. \n\
8400  2: also draw a grid at major tick positions in both\n\
8401  coordinates. \n\
8402  3: also draw a grid at minor tick positions in both\n\
8403  coordinates. \n\
8404  10: same as 0 except logarithmic x tick marks. (The x data\n\
8405  have to be converted to logarithms separately.) \n\
8406  11: same as 1 except logarithmic x tick marks. (The x data\n\
8407  have to be converted to logarithms separately.) \n\
8408  12: same as 2 except logarithmic x tick marks. (The x data\n\
8409  have to be converted to logarithms separately.) \n\
8410  13: same as 3 except logarithmic x tick marks. (The x data\n\
8411  have to be converted to logarithms separately.) \n\
8412  20: same as 0 except logarithmic y tick marks. (The y data\n\
8413  have to be converted to logarithms separately.) \n\
8414  21: same as 1 except logarithmic y tick marks. (The y data\n\
8415  have to be converted to logarithms separately.) \n\
8416  22: same as 2 except logarithmic y tick marks. (The y data\n\
8417  have to be converted to logarithms separately.) \n\
8418  23: same as 3 except logarithmic y tick marks. (The y data\n\
8419  have to be converted to logarithms separately.) \n\
8420  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8421  and y data have to be converted to logarithms separately.) \n\
8422  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8423  and y data have to be converted to logarithms separately.) \n\
8424  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8425  and y data have to be converted to logarithms separately.) \n\
8426  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8427  and y data have to be converted to logarithms separately.) \n\
8428  40: same as 0 except date / time x labels. \n\
8429  41: same as 1 except date / time x labels. \n\
8430  42: same as 2 except date / time x labels. \n\
8431  43: same as 3 except date / time x labels. \n\
8432  50: same as 0 except date / time y labels. \n\
8433  51: same as 1 except date / time y labels. \n\
8434  52: same as 2 except date / time y labels. \n\
8435  53: same as 3 except date / time y labels. \n\
8436  60: same as 0 except date / time x and y labels. \n\
8437  61: same as 1 except date / time x and y labels. \n\
8438  62: same as 2 except date / time x and y labels. \n\
8439  63: same as 3 except date / time x and y labels. \n\
8440  70: same as 0 except custom x and y labels. \n\
8441  71: same as 1 except custom x and y labels. \n\
8442  72: same as 2 except custom x and y labels. \n\
8443  73: same as 3 except custom x and y labels. \n\
8444 ";
8445 const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8446 Grid data from irregularly sampled data \n\
8447 \n\
8448 DESCRIPTION:\n\
8449 \n\
8450  Real world data is frequently irregularly sampled, but all PLplot 3D\n\
8451  plots require data placed in a uniform grid. This function takes\n\
8452  irregularly sampled data from three input arrays x[npts], y[npts], and\n\
8453  z[npts], reads the desired grid location from input arrays xg[nptsx]\n\
8454  and yg[nptsy], and returns the gridded data into output array\n\
8455  zg[nptsx][nptsy]. The algorithm used to grid the data is specified\n\
8456  with the argument type which can have one parameter specified in\n\
8457  argument data. \n\
8458 \n\
8459  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8460 \t Perl/PDL: Not available? \n\
8461 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8462 \n\
8463 \n\
8464  This function is used in example 21. \n\
8465 \n\
8466 \n\
8467 \n\
8468 SYNOPSIS:\n\
8469 \n\
8470 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8471 \n\
8472 ARGUMENTS:\n\
8473 \n\
8474  x (const PLFLT *, input) : The input x array. \n\
8475 \n\
8476  y (const PLFLT *, input) : The input y array. \n\
8477 \n\
8478  z (const PLFLT *, input) : The input z array. Each triple x[i],\n\
8479  y[i], z[i] represents one data sample coordinate. \n\
8480 \n\
8481  npts (PLINT, input) : The number of data samples in the x, y and z\n\
8482  arrays. \n\
8483 \n\
8484  xg (const PLFLT *, input) : The input array that specifies the grid\n\
8485  spacing in the x direction. Usually xg has nptsx equally spaced\n\
8486  values from the minimum to the maximum values of the x input\n\
8487  array. \n\
8488 \n\
8489  nptsx (PLINT, input) : The number of points in the xg array. \n\
8490 \n\
8491  yg (const PLFLT *, input) : The input array that specifies the grid\n\
8492  spacing in the y direction. Similar to the xg parameter. \n\
8493 \n\
8494  nptsy (PLINT, input) : The number of points in the yg array. \n\
8495 \n\
8496  zg (PLFLT **, output) : The output array, where data lies in the\n\
8497  regular grid specified by xg and yg. the zg array must exist or be\n\
8498  allocated by the user prior to the call, and must have dimension\n\
8499  zg[nptsx][nptsy]. \n\
8500 \n\
8501  type (PLINT, input) : The type of gridding algorithm to use, which\n\
8502  can be: GRID_CSA: Bivariate Cubic Spline approximation \n\
8503  GRID_DTLI: Delaunay Triangulation Linear Interpolation \n\
8504  GRID_NNI: Natural Neighbors Interpolation \n\
8505  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted \n\
8506  GRID_NNLI: Nearest Neighbors Linear Interpolation \n\
8507  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8508  Weighted \n\
8509  For details of the algorithms read the source file plgridd.c. \n\
8510 \n\
8511  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8512  which can be specified through this argument. Currently, for\n\
8513  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8514  use, the lower the value, the noisier (more local) the\n\
8515  approximation is. \n\
8516  GRID_NNLI, data specifies what a thin triangle is, in the\n\
8517  range [1. .. 2.]. High values enable the usage of very thin\n\
8518  triangles for interpolation, possibly resulting in error in\n\
8519  the approximation. \n\
8520  GRID_NNI, only weights greater than data will be accepted. If\n\
8521  0, all weights will be accepted. \n\
8522 ";
8523 const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8524 Clear current (sub)page \n\
8525 \n\
8526 DESCRIPTION:\n\
8527 \n\
8528  Clears the current page, effectively erasing everything that have been\n\
8529  drawn. This command only works with interactive drivers; if the\n\
8530  driver does not support this, the page is filled with the background\n\
8531  color in use. If the current page is divided into subpages, only the\n\
8532  current subpage is erased.\tThe nth subpage can be selected with\n\
8533  pladv(n). \n\
8534 \n\
8535  Redacted form: General: plclear()\n\
8536 \t Perl/PDL: Not available? \n\
8537 \n\
8538 \n\
8539  This function is not used in any examples. \n\
8540 \n\
8541 \n\
8542 \n\
8543 SYNOPSIS:\n\
8544 \n\
8545 plclear()\n\
8546 ";
8547 const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8548 Set cmap0 colors by 8-bit RGB values and double alpha transparency value \n\
8549 \n\
8550 DESCRIPTION:\n\
8551 \n\
8552  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8553  and floating point alpha transparency value. This sets the entire\n\
8554  color map -- only as many colors as specified will be allocated. \n\
8555 \n\
8556  Redacted form: plscmap0a(r, g, b, alpha)\n\
8557 \n\
8558  This function is used in examples 30. \n\
8559 \n\
8560 \n\
8561 \n\
8562 SYNOPSIS:\n\
8563 \n\
8564 plscmap0a(r, g, b, alpha, ncol0)\n\
8565 \n\
8566 ARGUMENTS:\n\
8567 \n\
8568  r (const PLINT *, input) : Pointer to array with set of unsigned\n\
8569  8-bit integers (0-255) representing the degree of red in the\n\
8570  color. \n\
8571 \n\
8572  g (const PLINT *, input) : Pointer to array with set of unsigned\n\
8573  8-bit integers (0-255) representing the degree of green in the\n\
8574  color. \n\
8575 \n\
8576  b (const PLINT *, input) : Pointer to array with set of unsigned\n\
8577  8-bit integers (0-255) representing the degree of blue in the\n\
8578  color. \n\
8579 \n\
8580  alpha (const PLFLT *, input) : Pointer to array with set of PLFLT\n\
8581  values (0.0 - 1.0) representing the alpha transparency of the\n\
8582  color. \n\
8583 \n\
8584  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8585  arrays. \n\
8586 ";
8587 const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
8588 Set 8-bit RGB values for given cmap0 color index \n\
8589 \n\
8590 DESCRIPTION:\n\
8591 \n\
8592  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8593  index. Overwrites the previous color value for the given index and,\n\
8594  thus, does not result in any additional allocation of space for\n\
8595  colors. \n\
8596 \n\
8597  Redacted form: plscol0(icol0, r, g, b)\n\
8598 \n\
8599  This function is used in any example 31. \n\
8600 \n\
8601 \n\
8602 \n\
8603 SYNOPSIS:\n\
8604 \n\
8605 plscol0(icol0, r, g, b)\n\
8606 \n\
8607 ARGUMENTS:\n\
8608 \n\
8609  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8610  number of colors (which is set by default, by plscmap0n, or even\n\
8611  by plscmap0). \n\
8612 \n\
8613  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8614  degree of red in the color. \n\
8615 \n\
8616  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8617  degree of green in the color. \n\
8618 \n\
8619  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8620  degree of blue in the color. \n\
8621 ";
8622 const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
8623 Set up transformation from metafile coordinates \n\
8624 \n\
8625 DESCRIPTION:\n\
8626 \n\
8627  Set up transformation from metafile coordinates. The size of the plot\n\
8628  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8629  general-purpose facility just yet (not sure why the user would need\n\
8630  it, for one). \n\
8631 \n\
8632  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8633  dimypmm)\n\
8634 \n\
8635  This function is not used in any examples. \n\
8636 \n\
8637 \n\
8638 \n\
8639 SYNOPSIS:\n\
8640 \n\
8641 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8642 \n\
8643 ARGUMENTS:\n\
8644 \n\
8645  dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
8646 \n\
8647  dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
8648 \n\
8649  dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
8650 \n\
8651  dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
8652 \n\
8653  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8654 \n\
8655  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
8656 ";
8657 const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
8658 Creates a new stream and makes it the default \n\
8659 \n\
8660 DESCRIPTION:\n\
8661 \n\
8662  Creates a new stream and makes it the default. Differs from using\n\
8663  plsstrm, in that a free stream number is found, and returned.\n\
8664  Unfortunately, I have to start at stream 1 and work upward, since\n\
8665  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8666  that no initial, library-opening call is required.\tSo stream 0 must\n\
8667  be preallocated, and there is no simple way of determining whether it\n\
8668  is already in use or not. \n\
8669 \n\
8670  Redacted form: plmkstrm(p_strm)\n\
8671 \n\
8672  This function is used in examples 1,20. \n\
8673 \n\
8674 \n\
8675 \n\
8676 SYNOPSIS:\n\
8677 \n\
8678 plmkstrm(p_strm)\n\
8679 \n\
8680 ARGUMENTS:\n\
8681 \n\
8682  p_strm (PLINT *, output) : Pointer to stream number of the created\n\
8683  stream. \n\
8684 ";
8685 const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
8686 Get page parameters \n\
8687 \n\
8688 DESCRIPTION:\n\
8689 \n\
8690  Gets the current page configuration. The length and offset values are\n\
8691  expressed in units that are specific to the current driver. For\n\
8692  instance: screen drivers will usually interpret them as number of\n\
8693  pixels, whereas printer drivers will usually use mm. \n\
8694 \n\
8695  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8696 \n\
8697  This function is used in examples 14 and 31. \n\
8698 \n\
8699 \n\
8700 \n\
8701 SYNOPSIS:\n\
8702 \n\
8703 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8704 \n\
8705 ARGUMENTS:\n\
8706 \n\
8707  p_xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
8708 \n\
8709  p_yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in\n\
8710  y. \n\
8711 \n\
8712  p_xleng (PLINT *, output) : Pointer to x page length value. \n\
8713 \n\
8714  p_yleng (PLINT *, output) : Pointer to y page length value. \n\
8715 \n\
8716  p_xoff (PLINT *, output) : Pointer to x page offset. \n\
8717 \n\
8718  p_yoff (PLINT *, output) : Pointer to y page offset. \n\
8719 ";
8720 const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
8721 Set format for date / time labels \n\
8722 \n\
8723 DESCRIPTION:\n\
8724 \n\
8725  Sets the format for date / time labels. To enable date / time format\n\
8726  labels see the options to plbox, plbox3, and plenv. \n\
8727 \n\
8728  Redacted form: pltimefmt(fmt)\n\
8729 \n\
8730  This function is used in example 29. \n\
8731 \n\
8732 \n\
8733 \n\
8734 SYNOPSIS:\n\
8735 \n\
8736 pltimefmt(fmt)\n\
8737 \n\
8738 ARGUMENTS:\n\
8739 \n\
8740  fmt (const char *, fmt) : This string is interpreted similarly to\n\
8741  the format specifier of typical system strftime routines except\n\
8742  that PLplot ignores locale and also supplies some useful\n\
8743  extensions in the context of plotting. All text in the string is\n\
8744  printed as-is other than conversion specifications which take the\n\
8745  form of a \'%\' character followed by further conversion\n\
8746  specification character. The conversion specifications which are\n\
8747  similar to those provided by system strftime routines are the\n\
8748  following: %a: The abbreviated (English) weekday name. \n\
8749  %A: The full (English) weekday name. \n\
8750  %b: The abbreviated (English) month name. \n\
8751  %B: The full (English) month name. \n\
8752  %c: Equivalent to %a %b %d %T %Y (non-ISO). \n\
8753  %C: The century number (year/100) as a 2-digit integer. \n\
8754  %d: The day of the month as a decimal number (range 01 to 31). \n\
8755  %D: Equivalent to %m/%d/%y (non-ISO). \n\
8756  %e: Like %d, but a leading zero is replaced by a space. \n\
8757  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format). \n\
8758  %h: Equivalent to %b. \n\
8759  %H: The hour as a decimal number using a 24-hour clock (range\n\
8760  00 to 23). \n\
8761  %I: The hour as a decimal number using a 12-hour clock (range\n\
8762  01 to 12). \n\
8763  %j: The day of the year as a decimal number (range 001 to\n\
8764  366). \n\
8765  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
8766  23); single digits are preceded by a blank. (See also %H.) \n\
8767  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
8768  12); single digits are preceded by a blank. (See also %I.) \n\
8769  %m: The month as a decimal number (range 01 to 12). \n\
8770  %M: The minute as a decimal number (range 00 to 59). \n\
8771  %n: A newline character. \n\
8772  %p: Either \"AM\" or \"PM\" according to the given time value. \n\
8773  Noon is treated as \"PM\" and midnight as \"AM\". \n\
8774  %r: Equivalent to %I:%M:%S %p. \n\
8775  %R: The time in 24-hour notation (%H:%M). For a version\n\
8776  including the seconds, see %T below. \n\
8777  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
8778  +0000 (UTC). \n\
8779  %S: The second as a decimal number (range 00 to 60). (The\n\
8780  range is up to 60 to allow for occasional leap seconds.) \n\
8781  %t: A tab character. \n\
8782  %T: The time in 24-hour notation (%H:%M:%S). \n\
8783  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
8784  being 1. See also %w. \n\
8785  %U: The week number of the current year as a decimal number,\n\
8786  range 00 to 53, starting with the first Sunday as the first\n\
8787  day of week 01. See also %V and %W. \n\
8788  %v: Equivalent to %e-%b-%Y. \n\
8789  %V: The ISO 8601 week number of the current year as a decimal\n\
8790  number, range 01 to 53, where week 1 is the first week that\n\
8791  has at least 4 days in the new year. See also %U and %W. \n\
8792  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
8793  being 0. See also %u. \n\
8794  %W: The week number of the current year as a decimal number,\n\
8795  range 00 to 53, starting with the first Monday as the first\n\
8796  day of week 01. \n\
8797  %x: Equivalent to %a %b %d %Y. \n\
8798  %X: Equivalent to %T. \n\
8799  %y: The year as a decimal number without a century (range 00\n\
8800  to 99). \n\
8801  %Y: The year as a decimal number including a century. \n\
8802  %z: The UTC time-zone string = \"+0000\". \n\
8803  %Z: The UTC time-zone abbreviation = \"UTC\". \n\
8804  %+: The UTC date and time in default format of the Unix date\n\
8805  command which is equivalent to %a %b %d %T %Z %Y. \n\
8806  %%: A literal \"%\" character. \n\
8807  The conversion specifications which are extensions to those normally\n\
8808  provided by system strftime routines are the following: %(0-9):\n\
8809  The fractional part of the seconds field (including leading\n\
8810  decimal point) to the specified accuracy. Thus %S%3 would give\n\
8811  seconds to millisecond accuracy (00.000). \n\
8812  %.: The fractional part of the seconds field (including\n\
8813  leading decimal point) to the maximum available accuracy. Thus\n\
8814  %S%. would give seconds with fractional part up to 9 decimal\n\
8815  places if available. \n\
8816 ";
8817 const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
8818 Specify viewport using aspect ratio only \n\
8819 \n\
8820 DESCRIPTION:\n\
8821 \n\
8822  Sets the viewport so that the ratio of the length of the y axis to\n\
8823  that of the x axis is equal to aspect. \n\
8824 \n\
8825  Redacted form: plvasp(aspect)\n\
8826 \n\
8827  This function is used in example 13. \n\
8828 \n\
8829 \n\
8830 \n\
8831 SYNOPSIS:\n\
8832 \n\
8833 plvasp(aspect)\n\
8834 \n\
8835 ARGUMENTS:\n\
8836 \n\
8837  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8838  axis. \n\
8839 ";
8840 const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
8841 Set output file name \n\
8842 \n\
8843 DESCRIPTION:\n\
8844 \n\
8845  Sets the current output file name, if applicable. If the file name\n\
8846  has not been specified and is required by the driver, the user will be\n\
8847  prompted for it. If using the X-windows output driver, this sets the\n\
8848  display name. This routine, if used, must be called before\n\
8849  initializing PLplot. \n\
8850 \n\
8851  Redacted form: plsfnam(fnam)\n\
8852 \n\
8853  This function is used in examples 1,20. \n\
8854 \n\
8855 \n\
8856 \n\
8857 SYNOPSIS:\n\
8858 \n\
8859 plsfnam(fnam)\n\
8860 \n\
8861 ARGUMENTS:\n\
8862 \n\
8863  fnam (const char *, input) : Pointer to file name string. \n\
8864 ";
8865 const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
8866 Vector plot \n\
8867 \n\
8868 DESCRIPTION:\n\
8869 \n\
8870  Draws a vector plot of the vector (\n\
8871  u[\n\
8872  nx][\n\
8873  ny],\n\
8874  v[\n\
8875  nx][\n\
8876  ny]) . The scaling factor for the vectors is given by scale. A\n\
8877  transformation routine pointed to by pltr with a pointer pltr_data for\n\
8878  additional data required by the transformation routine is used to map\n\
8879  indices within the array to the world coordinates. The style of the\n\
8880  vector arrow may be set using plsvect. \n\
8881 \n\
8882  Redacted form: plvect(u, v, scale, pltr, pltr_data)\n\
8883 \n\
8884  This function is used in example 22. \n\
8885 \n\
8886 \n\
8887 \n\
8888 SYNOPSIS:\n\
8889 \n\
8890 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
8891 \n\
8892 ARGUMENTS:\n\
8893 \n\
8894  u, v (const PLFLT * const *, input) : Pointers to a pair of\n\
8895  vectored two-dimensional arrays containing the x and y components\n\
8896  of the vector data to be plotted. \n\
8897 \n\
8898  nx, ny (PLINT, input) : Physical dimensions of the arrays u and v. \n\
8899 \n\
8900  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
8901  the vectors for plotting. If scale = 0 then the scaling factor is\n\
8902  automatically calculated for the data. If scale < 0 then the\n\
8903  scaling factor is automatically calculated for the data and then\n\
8904  multiplied by -\n\
8905  scale. If scale > 0 then the scaling factor is set to scale. \n\
8906 \n\
8907  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
8908  Pointer to function that defines transformation between indices\n\
8909  in array z and the world coordinates (C only). Transformation\n\
8910  functions are provided in the PLplot library: pltr0 for identity\n\
8911  mapping, and pltr1 and pltr2 for arbitrary mappings respectively\n\
8912  defined by one- and two-dimensional arrays. In addition,\n\
8913  user-supplied routines for the transformation can be used as well.\n\
8914  Examples of all of these approaches are given in the PLplot\n\
8915  documentation. The transformation function should have the form\n\
8916  given by any of pltr0, pltr1, or pltr2. \n\
8917 \n\
8918  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8919  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8920  externally supplied. \n\
8921 ";
8922 const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
8923 Set parameters that define current plot-space window \n\
8924 \n\
8925 DESCRIPTION:\n\
8926 \n\
8927  Set relative minima and maxima that define the current plot-space\n\
8928  window. If plsdiplt is not called the default values of xmin, ymin,\n\
8929  xmax, and ymax are 0., 0., 1., and 1. \n\
8930 \n\
8931  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
8932 \n\
8933  This function is used in example 31. \n\
8934 \n\
8935 \n\
8936 \n\
8937 SYNOPSIS:\n\
8938 \n\
8939 plsdiplt(xmin, ymin, xmax, ymax)\n\
8940 \n\
8941 ARGUMENTS:\n\
8942 \n\
8943  xmin (PLFLT, input) : Relative minimum in x. \n\
8944 \n\
8945  ymin (PLFLT, input) : Relative minimum in y. \n\
8946 \n\
8947  xmax (PLFLT, input) : Relative maximum in x. \n\
8948 \n\
8949  ymax (PLFLT, input) : Relative maximum in y. \n\
8950 ";
8951 const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
8952 Select line style \n\
8953 \n\
8954 DESCRIPTION:\n\
8955 \n\
8956  This sets the line style according to one of eight predefined patterns\n\
8957  (also see plstyl). \n\
8958 \n\
8959  Redacted form: pllsty(lin)\n\
8960 \n\
8961  This function is used in examples 9,12,22,25. \n\
8962 \n\
8963 \n\
8964 \n\
8965 SYNOPSIS:\n\
8966 \n\
8967 pllsty(lin)\n\
8968 \n\
8969 ARGUMENTS:\n\
8970 \n\
8971  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
8972  a continuous line, line style 2 is a line with short dashes and\n\
8973  gaps, line style 3 is a line with long dashes and gaps, line style\n\
8974  4 has long dashes and short gaps and so on. \n\
8975 ";
8976 const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
8977 Plot a glyph at the specified points \n\
8978 \n\
8979 DESCRIPTION:\n\
8980 \n\
8981  Plot a glyph at the specified points. (This function is largely\n\
8982  superseded by plstring which gives access to many[!] more glyphs.) \n\
8983 \n\
8984  Redacted form: plsym(x, y, code)\n\
8985 \n\
8986  This function is used in example 7. \n\
8987 \n\
8988 \n\
8989 \n\
8990 SYNOPSIS:\n\
8991 \n\
8992 plsym(n, x, y, code)\n\
8993 \n\
8994 ARGUMENTS:\n\
8995 \n\
8996  n (PLINT, input) : Number of points in the x and y arrays. \n\
8997 \n\
8998  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
8999  of points. \n\
9000 \n\
9001  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9002  of points. \n\
9003 \n\
9004  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9005  to be plotted at each of the n points. \n\
9006 ";
9007 const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9008 Set the device (keyword) name \n\
9009 \n\
9010 DESCRIPTION:\n\
9011 \n\
9012  Set the device (keyword) name. \n\
9013 \n\
9014  Redacted form: plsdev(devname)\n\
9015 \n\
9016  This function is used in examples 1,14,20. \n\
9017 \n\
9018 \n\
9019 \n\
9020 SYNOPSIS:\n\
9021 \n\
9022 plsdev(devname)\n\
9023 \n\
9024 ARGUMENTS:\n\
9025 \n\
9026  devname (const char *, input) : Pointer to device (keyword) name\n\
9027  string. \n\
9028 ";
9029 const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9030 Set the background color by 8-bit RGB value \n\
9031 \n\
9032 DESCRIPTION:\n\
9033 \n\
9034  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9035  (see the PLplot documentation). \n\
9036 \n\
9037  Redacted form: plscolbg(r, g, b)\n\
9038 \n\
9039  This function is used in examples 15,31. \n\
9040 \n\
9041 \n\
9042 \n\
9043 SYNOPSIS:\n\
9044 \n\
9045 plscolbg(r, g, b)\n\
9046 \n\
9047 ARGUMENTS:\n\
9048 \n\
9049  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9050  degree of red in the color. \n\
9051 \n\
9052  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9053  degree of green in the color. \n\
9054 \n\
9055  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9056  degree of blue in the color. \n\
9057 ";
9058 const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9059 Set parameters incrementally (zoom mode) that define current plot-space window \n\
9060 \n\
9061 DESCRIPTION:\n\
9062 \n\
9063  Set relative minima and maxima incrementally (zoom mode) that define\n\
9064  the current plot-space window. This function has the same effect as\n\
9065  plsdiplt if that function has not been previously called. Otherwise,\n\
9066  this function implements zoom mode using the transformation min_used =\n\
9067  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9068  each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9069  repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
9070 \n\
9071  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9072 \n\
9073  This function is used in example 31. \n\
9074 \n\
9075 \n\
9076 \n\
9077 SYNOPSIS:\n\
9078 \n\
9079 plsdiplz(xmin, ymin, xmax, ymax)\n\
9080 \n\
9081 ARGUMENTS:\n\
9082 \n\
9083  xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
9084 \n\
9085  ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
9086 \n\
9087  xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
9088 \n\
9089  ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
9090 ";
9091 const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9092 Advance to the next family file on the next new page \n\
9093 \n\
9094 DESCRIPTION:\n\
9095 \n\
9096  Advance to the next family file on the next new page. \n\
9097 \n\
9098  Redacted form: plfamadv()\n\
9099 \n\
9100  This function is not used in any examples. \n\
9101 \n\
9102 \n\
9103 \n\
9104 SYNOPSIS:\n\
9105 \n\
9106 plfamadv()\n\
9107 ";
9108 const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9109 Set number of colors in cmap0 \n\
9110 \n\
9111 DESCRIPTION:\n\
9112 \n\
9113  Set number of colors in color map0 (see the PLplot documentation).\n\
9114  Allocate (or reallocate) color map0, and fill with default values for\n\
9115  those colors not previously allocated. The first 16 default colors are\n\
9116  given in the plcol0 documentation. For larger indices the default\n\
9117  color is red. \n\
9118 \n\
9119  The drivers are not guaranteed to support more than 16 colors. \n\
9120 \n\
9121  Redacted form: plscmap0n(ncol0)\n\
9122 \n\
9123  This function is used in examples 15,16,24. \n\
9124 \n\
9125 \n\
9126 \n\
9127 SYNOPSIS:\n\
9128 \n\
9129 plscmap0n(ncol0)\n\
9130 \n\
9131 ARGUMENTS:\n\
9132 \n\
9133  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9134  the map0 palette. If this number is zero or less, then the value\n\
9135  from the previous call to plscmap0n is used and if there is no\n\
9136  previous call, then a default value is used. \n\
9137 ";
9138 const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9139 Plot latitude and longitude lines \n\
9140 \n\
9141 DESCRIPTION:\n\
9142 \n\
9143  Displays latitude and longitude on the current plot. The lines are\n\
9144  plotted in the current color and line style. \n\
9145 \n\
9146  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9147  minlat, maxlat)\n\
9148 \n\
9149  This function is used in example 19. \n\
9150 \n\
9151 \n\
9152 \n\
9153 SYNOPSIS:\n\
9154 \n\
9155 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9156 \n\
9157 ARGUMENTS:\n\
9158 \n\
9159  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
9160  supplied function to transform the coordinate longitudes and\n\
9161  latitudes to a plot coordinate system. By using this transform, we\n\
9162  can change from a longitude, latitude coordinate to a polar\n\
9163  stereographic project, for example. Initially, x[0]..[n-1] are\n\
9164  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
9165  After the call to mapform(), x[] and y[] should be replaced by the\n\
9166  corresponding plot coordinates. If no transform is desired,\n\
9167  mapform can be replaced by NULL. \n\
9168 \n\
9169  dlong (PLFLT, input) : The interval in degrees at which the\n\
9170  longitude lines are to be plotted. \n\
9171 \n\
9172  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9173  lines are to be plotted. \n\
9174 \n\
9175  minlong (PLFLT, input) : The value of the longitude on the left\n\
9176  side of the plot. The value of minlong must be less than the value\n\
9177  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9178  equal to 360. \n\
9179 \n\
9180  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9181  side of the plot. \n\
9182 \n\
9183  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9184  background. One can always use -90.0 as the boundary outside the\n\
9185  plot window will be automatically eliminated. However, the\n\
9186  program will be faster if one can reduce the size of the\n\
9187  background plotted. \n\
9188 \n\
9189  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9190  background. One can always use 90.0 as the boundary outside the\n\
9191  plot window will be automatically eliminated. \n\
9192 ";
9193 const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9194 Convert RGB color to HLS \n\
9195 \n\
9196 DESCRIPTION:\n\
9197 \n\
9198  Convert RGB color coordinates to HLS \n\
9199 \n\
9200  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9201 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
9202 \n\
9203 \n\
9204  This function is used in example 2. \n\
9205 \n\
9206 \n\
9207 \n\
9208 SYNOPSIS:\n\
9209 \n\
9210 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9211 \n\
9212 ARGUMENTS:\n\
9213 \n\
9214  r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
9215 \n\
9216  g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
9217 \n\
9218  b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
9219 \n\
9220  p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
9221  cone (0.0-360.0) \n\
9222 \n\
9223  p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
9224  fraction of the axis of the colour cone (0.0-1.0) \n\
9225 \n\
9226  p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
9227  fraction of the radius of the colour cone (0.0-1.0) \n\
9228 ";
9229 const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9230 Plot a glyph at the specified 3D points \n\
9231 \n\
9232 DESCRIPTION:\n\
9233 \n\
9234  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9235  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9236  this function similar to what is done for plline3. The glyph is\n\
9237  specified with a PLplot user string. Note that the user string is not\n\
9238  actually limited to one glyph so it is possible (but not normally\n\
9239  useful) to plot more than one glyph at the specified points with this\n\
9240  function. As with plmtex and plptex, the user string can contain FCI\n\
9241  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9242  else PLplot escapes for Hershey or unicode text to determine the\n\
9243  glyph. \n\
9244 \n\
9245  Redacted form: plstring3(x, y, z, string)\n\
9246 \n\
9247  This function is used in example 18. \n\
9248 \n\
9249 \n\
9250 \n\
9251 SYNOPSIS:\n\
9252 \n\
9253 plstring3(n, x, y, z, string)\n\
9254 \n\
9255 ARGUMENTS:\n\
9256 \n\
9257  n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
9258 \n\
9259  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9260  of points. \n\
9261 \n\
9262  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9263  of points. \n\
9264 \n\
9265  z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9266  of points. \n\
9267 \n\
9268  string (const char *, input) : PLplot user string corresponding to\n\
9269  the glyph to be plotted at each of the n points. \n\
9270 ";
9271 const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9272 Switch to text screen \n\
9273 \n\
9274 DESCRIPTION:\n\
9275 \n\
9276  Sets an interactive device to text mode, used in conjunction with\n\
9277  plgra to allow graphics and text to be interspersed. On a device\n\
9278  which supports separate text and graphics windows, this command causes\n\
9279  control to be switched to the text window.\tThis can be useful for\n\
9280  printing diagnostic messages or getting user input, which would\n\
9281  otherwise interfere with the plots. The program must switch back to\n\
9282  the graphics window before issuing plot commands, as the text (or\n\
9283  console) device will probably become quite confused otherwise. If\n\
9284  already in text mode, this command is ignored. It is also ignored on\n\
9285  devices which only support a single window or use a different method\n\
9286  for shifting focus (see also plgra). \n\
9287 \n\
9288  Redacted form: pltext()\n\
9289 \n\
9290  This function is used in example 1. \n\
9291 \n\
9292 \n\
9293 \n\
9294 SYNOPSIS:\n\
9295 \n\
9296 pltext()\n\
9297 ";
9298 const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9299 Get parameters that define current plot-space window \n\
9300 \n\
9301 DESCRIPTION:\n\
9302 \n\
9303  Get relative minima and maxima that define current plot-space window.\n\
9304  If plsdiplt has not been called the default values pointed to by\n\
9305  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
9306 \n\
9307  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9308 \n\
9309  This function is used in example 31. \n\
9310 \n\
9311 \n\
9312 \n\
9313 SYNOPSIS:\n\
9314 \n\
9315 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9316 \n\
9317 ARGUMENTS:\n\
9318 \n\
9319  p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
9320 \n\
9321  p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
9322 \n\
9323  p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
9324 \n\
9325  p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
9326 ";
9327 const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9328 Get the (current) run level \n\
9329 \n\
9330 DESCRIPTION:\n\
9331 \n\
9332  Get the (current) run level. Valid settings are: 0, uninitialized \n\
9333 \t 1,\tinitialized \n\
9334 \t 2,\tviewport defined \n\
9335 \t 3,\tworld coordinates defined \n\
9336 \n\
9337 \n\
9338  Redacted form: plglevel(p_level)\n\
9339 \n\
9340  This function is used in example 31. \n\
9341 \n\
9342 \n\
9343 \n\
9344 SYNOPSIS:\n\
9345 \n\
9346 plglevel(p_level)\n\
9347 \n\
9348 ARGUMENTS:\n\
9349 \n\
9350  p_level (PLINT *, output) : Pointer to the run level. \n\
9351 ";
9352 const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9353 Plot a histogram from binned data \n\
9354 \n\
9355 DESCRIPTION:\n\
9356 \n\
9357  Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9358  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9359  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9360  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9361  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9362  placed midway between the values in the x array. Also see plhist for\n\
9363  drawing histograms from unbinned data. \n\
9364 \n\
9365  Redacted form: General: plbin(x, y, opt)\n\
9366 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9367 \t Python: plbin(nbin, x, y, opt)\n\
9368 \n\
9369 \n\
9370  This function is not used in any examples. \n\
9371 \n\
9372 \n\
9373 \n\
9374 SYNOPSIS:\n\
9375 \n\
9376 plbin(nbin, x, y, opt)\n\
9377 \n\
9378 ARGUMENTS:\n\
9379 \n\
9380  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9381  and y arrays.) \n\
9382 \n\
9383  x (const PLFLT *, input) : Pointer to array containing values\n\
9384  associated with bins. These must form a strictly increasing\n\
9385  sequence. \n\
9386 \n\
9387  y (const PLFLT *, input) : Pointer to array containing number of\n\
9388  points in bin. This is a PLFLT (instead of PLINT) array so as to\n\
9389  allow histograms of probabilities, etc. \n\
9390 \n\
9391  opt (PLINT, input) : Is a combination of several flags:\n\
9392  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9393  outer bins are expanded to fill up the entire x-axis and bins of\n\
9394  zero height are simply drawn. \n\
9395  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9396  between the x values. If the values in x are equally spaced,\n\
9397  the values are the center values of the bins. \n\
9398  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9399  size as the ones inside. \n\
9400  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9401  (there is a gap for such bins). \n\
9402 ";
9403 const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9404 Plot a 2D matrix using cmap1 \n\
9405 \n\
9406 DESCRIPTION:\n\
9407 \n\
9408  Plot a 2D matrix using cmap1. \n\
9409 \n\
9410  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax,\n\
9411  zmin, zmax, valuemin, valuemax, pltr, pltr_data) \n\
9412 \n\
9413 \n\
9414  This function is used in example 20. \n\
9415 \n\
9416 \n\
9417 \n\
9418 SYNOPSIS:\n\
9419 \n\
9420 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9421 \n\
9422 ARGUMENTS:\n\
9423 \n\
9424  idata (const PLFLT * const *, input) : A 2D array of values\n\
9425  (intensities) to plot. Should have dimensions idata[nx][ny]. \n\
9426 \n\
9427  nx, ny (PLINT, input) : Dimensions of idata \n\
9428 \n\
9429  xmin, xmax, ymin, ymax (PLFLT, input) : Stretch image data to these\n\
9430  Plot coordinates. idata[0][0] corresponds to (xmin, ymin) and\n\
9431  idata[nx - 1][ny - 1] corresponds to (xmax, ymax). \n\
9432 \n\
9433  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9434  (inclusive) will be plotted. \n\
9435 \n\
9436  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9437  values to use for value to color mappings. A datum equal to or\n\
9438  less than valuemin will be plotted with color 0.0, while a datum\n\
9439  equal to or greater than valuemax will be plotted with color 1.0. \n\
9440  Data between valuemin and valuemax map linearly to colors between\n\
9441  0.0 and 1.0. \n\
9442 \n\
9443  pltr (void (*) (PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) , input) : \n\
9444  Pointer to function that defines a transformation between the\n\
9445  data in the array idata and world coordinates. An input\n\
9446  coordinate of (0, 0) corresponds to the \"top-left\" corner of idata\n\
9447  while (nx, ny) corresponds to the \"bottom-right\" corner of idata. \n\
9448  Some transformation functions are provided in the PLplot library:\n\
9449  pltr0 for identity mapping, and pltr1 and pltr2 for arbitrary\n\
9450  mappings respectively defined by one- and two-dimensional arrays. \n\
9451  In addition, user-supplied routines for the transformation can be\n\
9452  used as well. Examples of all of these approaches are given in\n\
9453  the PLplot documentation. The transformation function should have\n\
9454  the form given by any of pltr0, pltr1, or pltr2. \n\
9455 \n\
9456  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9457  information to pltr0, pltr1, pltr2, or whatever routine is\n\
9458  externally supplied. \n\
9459 ";
9460 const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
9461 Get family, style and weight of the current font \n\
9462 \n\
9463 DESCRIPTION:\n\
9464 \n\
9465  Gets information about current font. See the PLplot documentation for\n\
9466  more information on font selection. \n\
9467 \n\
9468  Redacted form: plgfont(p_family, p_style, p_weight)\n\
9469 \n\
9470  This function is used in example 23. \n\
9471 \n\
9472 \n\
9473 \n\
9474 SYNOPSIS:\n\
9475 \n\
9476 plgfont(p_family, p_style, p_weight)\n\
9477 \n\
9478 ARGUMENTS:\n\
9479 \n\
9480  p_family (PLINT *, output) : Pointer to variable with the current\n\
9481  font family. The available values are given by the PL_FCI_*\n\
9482  constants in plplot.h. Current options are PL_FCI_SANS,\n\
9483  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9484  p_family is NULL then the font family is not returned. \n\
9485 \n\
9486  p_style (PLINT *, output) : Pointer to variable with the current\n\
9487  font style. The available values are given by the PL_FCI_*\n\
9488  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9489  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
9490  font style is not returned. \n\
9491 \n\
9492  p_weight (PLINT *, output) : Pointer to variable with the current\n\
9493  font weight. The available values are given by the PL_FCI_*\n\
9494  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9495  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9496  returned. \n\
9497 ";
9498 const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
9499 Get z axis parameters \n\
9500 \n\
9501 DESCRIPTION:\n\
9502 \n\
9503  Identical to plgxax, except that arguments are flags for z axis. See\n\
9504  the description of plgxax for more detail. \n\
9505 \n\
9506  Redacted form: plgzax(p_digmax, p_digits)\n\
9507 \n\
9508  This function is used in example 31. \n\
9509 \n\
9510 \n\
9511 \n\
9512 SYNOPSIS:\n\
9513 \n\
9514 plgzax(p_digmax, p_digits)\n\
9515 \n\
9516 ARGUMENTS:\n\
9517 \n\
9518  p_digmax (PLINT *, output) : Pointer to variable with the maximum\n\
9519  number of digits for the z axis. If nonzero, the printed label\n\
9520  has been switched to a floating point representation when the\n\
9521  number of digits exceeds p_digmax. \n\
9522 \n\
9523  p_digits (PLINT *, output) : Pointer to variable with the actual\n\
9524  number of digits for the numeric labels (z axis) from the last\n\
9525  plot. \n\
9526 ";
9527 const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
9528 Write text inside the viewport of a 3D plot \n\
9529 \n\
9530 DESCRIPTION:\n\
9531 \n\
9532  Writes text at a specified position and inclination and with a\n\
9533  specified shear within the viewport. Text is clipped at the viewport\n\
9534  boundaries. The reference point of a string lies along a line passing\n\
9535  through the string at half the height of a capital letter.\tThe\n\
9536  position of the reference point along this line is determined by just,\n\
9537  and the reference point is placed at world coordinates (\n\
9538  wx, \n\
9539  wy, \n\
9540  wz) within the viewport. The inclination and shear of the string is\n\
9541  specified in terms of differences of world coordinates making it easy\n\
9542  to write text parallel to a line in a graph. \n\
9543 \n\
9544  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text) \n\
9545 \n\
9546  This function is used in example 28. \n\
9547 \n\
9548 \n\
9549 \n\
9550 SYNOPSIS:\n\
9551 \n\
9552 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9553 \n\
9554 ARGUMENTS:\n\
9555 \n\
9556  wx (PLFLT, input) : x world coordinate of reference point of\n\
9557  string. \n\
9558 \n\
9559  wy (PLFLT, input) : y world coordinate of reference point of\n\
9560  string. \n\
9561 \n\
9562  wz (PLFLT, input) : z world coordinate of reference point of\n\
9563  string. \n\
9564 \n\
9565  dx (PLFLT, input) : Together with dy and \n\
9566  dz , this specifies the inclination of the string. The baseline of\n\
9567  the string is parallel to a line joining (\n\
9568  x, \n\
9569  y, \n\
9570  z) to (\n\
9571  x+\n\
9572  dx, \n\
9573  y+\n\
9574  dy, \n\
9575  z+\n\
9576  dz) . \n\
9577 \n\
9578  dy (PLFLT, input) : Together with dx and \n\
9579  dz, this specifies the inclination of the string. \n\
9580 \n\
9581  dz (PLFLT, input) : Together with dx and \n\
9582  dy, this specifies the inclination of the string. \n\
9583 \n\
9584  sx (PLFLT, input) : Together with sy and \n\
9585  sz , this specifies the shear of the string. The string is sheared so\n\
9586  that the characters are vertically parallel to a line joining (\n\
9587  x, \n\
9588  y, \n\
9589  z) to (\n\
9590  x+\n\
9591  sx, \n\
9592  y+\n\
9593  sy, \n\
9594  z+\n\
9595  sz) . If sx = \n\
9596  sy = \n\
9597  sz = 0.) then the text is not sheared. \n\
9598 \n\
9599  sy (PLFLT, input) : Together with sx and \n\
9600  sz, this specifies shear of the string. \n\
9601 \n\
9602  sz (PLFLT, input) : Together with sx and \n\
9603  sy, this specifies shear of the string. \n\
9604 \n\
9605  just (PLFLT, input) : Specifies the position of the string relative\n\
9606  to its reference point. If just=0. , the reference point is at\n\
9607  the left and if just=1. , it is at the right of the string. Other\n\
9608  values of just give intermediate justifications. \n\
9609 \n\
9610  text (const char *, input) : The string to be written out. \n\
9611 ";
9612 const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
9613 Draw a box with axes, etc. with arbitrary origin \n\
9614 \n\
9615 DESCRIPTION:\n\
9616 \n\
9617  Draws a box around the currently defined viewport with arbitrary\n\
9618  world-coordinate origin specified by x0 and y0 and labels it with\n\
9619  world coordinate values appropriate to the window.\tThus plaxes should\n\
9620  only be called after defining both viewport and window. The character\n\
9621  strings xopt and yopt specify how the box should be drawn as described\n\
9622  below. If ticks and/or subticks are to be drawn for a particular\n\
9623  axis, the tick intervals and number of subintervals may be specified\n\
9624  explicitly, or they may be defaulted by setting the appropriate\n\
9625  arguments to zero. \n\
9626 \n\
9627  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9628  ytick, nysub)\n\
9629 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9630  yopt)\n\
9631 \n\
9632 \n\
9633  This function is not used in any examples. \n\
9634 \n\
9635 \n\
9636 \n\
9637 SYNOPSIS:\n\
9638 \n\
9639 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9640 \n\
9641 ARGUMENTS:\n\
9642 \n\
9643  x0 (PLFLT, input) : World X coordinate of origin. \n\
9644 \n\
9645  y0 (PLFLT, input) : World Y coordinate of origin. \n\
9646 \n\
9647  xopt (const char *, input) : Pointer to character string specifying\n\
9648  options for horizontal axis. The string can include any\n\
9649  combination of the following letters (upper or lower case) in any\n\
9650  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
9651  is vertical line (x=0). \n\
9652  b: Draws bottom (X) or left (Y) edge of frame. \n\
9653  c: Draws top (X) or right (Y) edge of frame. \n\
9654  d: Plot labels as date / time. Values are assumed to be\n\
9655  seconds since the epoch (as used by gmtime). \n\
9656  f: Always use fixed point numeric labels. \n\
9657  g: Draws a grid at the major tick interval. \n\
9658  h: Draws a grid at the minor tick interval. \n\
9659  i: Inverts tick marks, so they are drawn outwards, rather than\n\
9660  inwards. \n\
9661  l: Labels axis logarithmically. This only affects the labels,\n\
9662  not the data, and so it is necessary to compute the logarithms\n\
9663  of data points before passing them to any of the drawing\n\
9664  routines. \n\
9665  m: Writes numeric labels at major tick intervals in the\n\
9666  unconventional location (above box for X, right of box for Y). \n\
9667  n: Writes numeric labels at major tick intervals in the\n\
9668  conventional location (below box for X, left of box for Y). \n\
9669  o: Use custom labelling function to generate axis label text. \n\
9670  The custom labelling function can be defined with the\n\
9671  plslabelfunc command. \n\
9672  s: Enables subticks between major ticks, only valid if t is\n\
9673  also specified. \n\
9674  t: Draws major ticks. \n\
9675  u: Exactly like \"b\" except don\'t draw edge line. \n\
9676  w: Exactly like \"c\" except don\'t draw edge line. \n\
9677  x: Exactly like \"t\" (including the side effect of the\n\
9678  numerical labels for the major ticks) except exclude drawing\n\
9679  the major and minor tick marks. \n\
9680 \n\
9681 \n\
9682  xtick (PLFLT, input) : World coordinate interval between major\n\
9683  ticks on the x axis. If it is set to zero, PLplot automatically\n\
9684  generates a suitable tick interval. \n\
9685 \n\
9686  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9687  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9688  generates a suitable minor tick interval. \n\
9689 \n\
9690  yopt (const char *, input) : Pointer to character string specifying\n\
9691  options for vertical axis. The string can include any combination\n\
9692  of the letters defined above for xopt, and in addition may\n\
9693  contain: v: Write numeric labels for vertical axis parallel to the\n\
9694  base of the graph, rather than parallel to the axis. \n\
9695 \n\
9696 \n\
9697  ytick (PLFLT, input) : World coordinate interval between major\n\
9698  ticks on the y axis. If it is set to zero, PLplot automatically\n\
9699  generates a suitable tick interval. \n\
9700 \n\
9701  nysub (PLINT, input) : Number of subintervals between major y axis\n\
9702  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9703  generates a suitable minor tick interval. \n\
9704 ";
9705 const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
9706 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
9707 \n\
9708 DESCRIPTION:\n\
9709 \n\
9710  Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
9711 \n\
9712  Redacted form: plgcolbg(r, g, b)\n\
9713 \n\
9714  This function is used in example 31. \n\
9715 \n\
9716 \n\
9717 \n\
9718 SYNOPSIS:\n\
9719 \n\
9720 plgcolbg(r, g, b)\n\
9721 \n\
9722 ARGUMENTS:\n\
9723 \n\
9724  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9725  representing the degree of red in the color. \n\
9726 \n\
9727  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9728  representing the degree of green in the color. \n\
9729 \n\
9730  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9731  representing the degree of blue in the color. \n\
9732 ";
9733 const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
9734 Plot a glyph at the specified 3D points \n\
9735 \n\
9736 DESCRIPTION:\n\
9737 \n\
9738  Plot a glyph at the specified 3D points. (This function is largely\n\
9739  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9740  Set up the call to this function similar to what is done for plline3.\n\
9741  code=-1 means try to just draw a point. Right now it\'s just a move\n\
9742  and a draw at the same place. Not ideal, since a sufficiently\n\
9743  intelligent output device may optimize it away, or there may be faster\n\
9744  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9745  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9746  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9747  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9748  code <= 127 the corresponding printable ASCII character is plotted. \n\
9749 \n\
9750  Redacted form: plpoin3(x, y, z, code)\n\
9751 \n\
9752  This function is not used in any example. \n\
9753 \n\
9754 \n\
9755 \n\
9756 SYNOPSIS:\n\
9757 \n\
9758 plpoin3(n, x, y, z, code)\n\
9759 \n\
9760 ARGUMENTS:\n\
9761 \n\
9762  n (PLINT, input) : Number of points in the x and y arrays. \n\
9763 \n\
9764  x (const PLFLT *, input) : Pointer to an array with X coordinates\n\
9765  of points. \n\
9766 \n\
9767  y (const PLFLT *, input) : Pointer to an array with Y coordinates\n\
9768  of points. \n\
9769 \n\
9770  z (const PLFLT *, input) : Pointer to an array with Z coordinates\n\
9771  of points. \n\
9772 \n\
9773  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
9774  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
9775  each of the n points. \n\
9776 ";
9777 const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
9778 Draw a polygon in 3 space \n\
9779 \n\
9780 DESCRIPTION:\n\
9781 \n\
9782  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
9783  like plline3, but differs from that function in that plpoly3 attempts\n\
9784  to determine if the polygon is viewable depending on the order of the\n\
9785  points within the arrays and the value of ifcc. If the back of\n\
9786  polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
9787  you want, then use plline3 instead. \n\
9788 \n\
9789  The points are assumed to be in a plane, and the directionality of the\n\
9790  plane is determined from the first three points. Additional points do\n\
9791  not have to lie on the plane defined by the first three, but if they\n\
9792  do not, then the determination of visibility obviously can\'t be 100%\n\
9793  accurate... So if you\'re 3 space polygons are too far from planar,\n\
9794  consider breaking them into smaller polygons. 3 points define a plane\n\
9795  :-). \n\
9796 \n\
9797  Bugs: If one of the first two segments is of zero length, or if they\n\
9798  are co-linear, the calculation of visibility has a 50/50 chance of\n\
9799  being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
9800  of this problem. (Search for 20.1). \n\
9801 \n\
9802  Redacted form: plpoly3(x, y, z, code)\n\
9803 \n\
9804  This function is used in example 18. \n\
9805 \n\
9806 \n\
9807 \n\
9808 SYNOPSIS:\n\
9809 \n\
9810 plpoly3(n, x, y, z, draw, ifcc)\n\
9811 \n\
9812 ARGUMENTS:\n\
9813 \n\
9814  n (PLINT, input) : Number of points defining line. \n\
9815 \n\
9816  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
9817  points. \n\
9818 \n\
9819  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9820  points. \n\
9821 \n\
9822  z (const PLFLT *, input) : Pointer to array with z coordinates of\n\
9823  points. \n\
9824 \n\
9825  draw (const PLBOOL *, input) : Pointer to array which controls\n\
9826  drawing the segments of the polygon. If draw[i] is true, then the\n\
9827  polygon segment from index [i] to [i+1] is drawn, otherwise, not. \n\
9828 \n\
9829  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
9830  polygon is determined by assuming the points are laid out in a\n\
9831  counter-clockwise order. Otherwise, the directionality of the\n\
9832  polygon is determined by assuming the points are laid out in a\n\
9833  clockwise order. \n\
9834 ";
9835 const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
9836 Set the background color by 8-bit RGB value and double alpha transparency value. \n\
9837 \n\
9838 DESCRIPTION:\n\
9839 \n\
9840  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
9841  (see the PLplot documentation) and double alpha transparency value. \n\
9842 \n\
9843  This function is used in example 31. \n\
9844 \n\
9845 \n\
9846 \n\
9847 SYNOPSIS:\n\
9848 \n\
9849 plscolbga(r, g, b, alpha)\n\
9850 \n\
9851 ARGUMENTS:\n\
9852 \n\
9853  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9854  degree of red in the color. \n\
9855 \n\
9856  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9857  degree of green in the color. \n\
9858 \n\
9859  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9860  degree of blue in the color. \n\
9861 \n\
9862  alpha (PLFLT, input) : double value (0.0-1.0) representing the\n\
9863  alpha transparency value of the color. \n\
9864 ";
9865 const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
9866 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha transparency value \n\
9867 \n\
9868 DESCRIPTION:\n\
9869 \n\
9870  Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
9871  alpha transparency value. \n\
9872 \n\
9873  This function is used in example 31. \n\
9874 \n\
9875 \n\
9876 \n\
9877 SYNOPSIS:\n\
9878 \n\
9879 plgcolbga(r, g, b, alpha)\n\
9880 \n\
9881 ARGUMENTS:\n\
9882 \n\
9883  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9884  representing the degree of red in the color. \n\
9885 \n\
9886  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9887  representing the degree of green in the color. \n\
9888 \n\
9889  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
9890  representing the degree of blue in the color. \n\
9891 \n\
9892  alpha (PLFLT *, output) : Pointer to PLFLT alpha transparency\n\
9893  value. \n\
9894 ";
9895 const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
9896 Draw x error bar \n\
9897 \n\
9898 DESCRIPTION:\n\
9899 \n\
9900  Draws a set of n horizontal error bars, the i\'th error bar extending\n\
9901  from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
9902  error bar are of length equal to the minor tick length (settable using\n\
9903  plsmin). \n\
9904 \n\
9905  Redacted form: General: plerrx(xmin, ymax, y)\n\
9906 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
9907 \n\
9908 \n\
9909  This function is used in example 29. \n\
9910 \n\
9911 \n\
9912 \n\
9913 SYNOPSIS:\n\
9914 \n\
9915 plerrx(n, xmin, xmax, y)\n\
9916 \n\
9917 ARGUMENTS:\n\
9918 \n\
9919  n (PLINT, input) : Number of error bars to draw. \n\
9920 \n\
9921  xmin (const PLFLT *, input) : Pointer to array with x coordinates\n\
9922  of left-hand endpoint of error bars. \n\
9923 \n\
9924  xmax (const PLFLT *, input) : Pointer to array with x coordinates\n\
9925  of right-hand endpoint of error bars. \n\
9926 \n\
9927  y (const PLFLT *, input) : Pointer to array with y coordinates of\n\
9928  error bar. \n\
9929 ";
9930 const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
9931 Eject current page \n\
9932 \n\
9933 DESCRIPTION:\n\
9934 \n\
9935  Clears the graphics screen of an interactive device, or ejects a page\n\
9936  on a plotter. See plbop for more information. \n\
9937 \n\
9938  Redacted form: pleop()\n\
9939 \n\
9940  This function is used in example 2,14. \n\
9941 \n\
9942 \n\
9943 \n\
9944 SYNOPSIS:\n\
9945 \n\
9946 pleop()\n\
9947 ";
9948 const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
9949 Convert HLS color to RGB \n\
9950 \n\
9951 DESCRIPTION:\n\
9952 \n\
9953  Convert HLS color coordinates to RGB. \n\
9954 \n\
9955  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9956 \t Perl/PDL: Not available? Implemented as plhls? \n\
9957 \n\
9958 \n\
9959  This function is used in example 2. \n\
9960 \n\
9961 \n\
9962 \n\
9963 SYNOPSIS:\n\
9964 \n\
9965 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
9966 \n\
9967 ARGUMENTS:\n\
9968 \n\
9969  h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
9970 \n\
9971  l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
9972  of the colour cone (0.0-1.0) \n\
9973 \n\
9974  s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
9975  radius of the colour cone (0.0-1.0) \n\
9976 \n\
9977  p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
9978  colour \n\
9979 \n\
9980  p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
9981  colour \n\
9982 \n\
9983  p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
9984  colour \n\
9985 ";
9986 const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
9987 Plot all or a subset of Shapefile data, filling the polygons \n\
9988 \n\
9989 DESCRIPTION:\n\
9990 \n\
9991  As per plmapline, however the items are filled in the same way as\n\
9992  plfill. \n\
9993 \n\
9994  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
9995  plotentries)\n\
9996 \n\
9997  This function is used in example 19. \n\
9998 \n\
9999 \n\
10000 \n\
10001 SYNOPSIS:\n\
10002 \n\
10003 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10004 \n\
10005 ARGUMENTS:\n\
10006 \n\
10007  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
10008  supplied function to transform the coordinates given in the\n\
10009  shapefile into a plot coordinate system. By using this transform,\n\
10010  we can change from a longitude, latitude coordinate to a polar\n\
10011  stereographic project, for example. Initially, x[0]..[n-1] are\n\
10012  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
10013  After the call to mapform(), x[] and y[] should be replaced by the\n\
10014  corresponding plot coordinates. If no transform is desired,\n\
10015  mapform can be replaced by NULL. \n\
10016 \n\
10017  name (const char *, input) : The file name of a set of Shapefile\n\
10018  files without the file extension. \n\
10019 \n\
10020  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10021  be in the same units as used by the Shapefile. You could use a\n\
10022  very large negative number to plot everything, but you can improve\n\
10023  performance by limiting the area drawn. The units must match those\n\
10024  of the Shapefile projection, which may be for example longitude or\n\
10025  distance. The value of minx must be less than the value of maxx. \n\
10026 \n\
10027  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10028  use a very large number to plot everything, but you can improve\n\
10029  performance by limiting the area drawn. \n\
10030 \n\
10031  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10032  be in the same units as used by the Shapefile. You could use a\n\
10033  very large negative number to plot everything, but you can improve\n\
10034  performance by limiting the area drawn. The units must match those\n\
10035  of the Shapefile projection, which may be for example latitude or\n\
10036  distance. The value of miny must be less than the value of maxy. \n\
10037 \n\
10038  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10039  use a very large number to plot everything, but you can improve\n\
10040  performance by limiting the area drawn. \n\
10041 \n\
10042  plotentries (const PLINT *, input) : An array of integers\n\
10043  indicating the elements of the Shapefile (zero indexed) which will\n\
10044  be drawn. Setting plotentries to NULL will plot all elements of\n\
10045  the Shapefile. \n\
10046 \n\
10047  nplotentries (PLINT, input) : The number of items in plotentries.\n\
10048  Ignored if plotentries is NULL. \n\
10049 ";
10050 const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10051 Draw y error bar \n\
10052 \n\
10053 DESCRIPTION:\n\
10054 \n\
10055  Draws a set of n vertical error bars, the i\'th error bar extending\n\
10056  from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
10057  error bar are of length equal to the minor tick length (settable using\n\
10058  plsmin). \n\
10059 \n\
10060  Redacted form: General: plerry(x, ymin, ymax)\n\
10061 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
10062 \n\
10063 \n\
10064  This function is used in example 29. \n\
10065 \n\
10066 \n\
10067 \n\
10068 SYNOPSIS:\n\
10069 \n\
10070 plerry(n, x, ymin, ymax)\n\
10071 \n\
10072 ARGUMENTS:\n\
10073 \n\
10074  n (PLINT, input) : Number of error bars to draw. \n\
10075 \n\
10076  x (const PLFLT *, input) : Pointer to array with x coordinates of\n\
10077  error bars. \n\
10078 \n\
10079  ymin (const PLFLT *, input) : Pointer to array with y coordinates\n\
10080  of lower endpoint of error bars. \n\
10081 \n\
10082  ymax (const PLFLT *, input) : Pointer to array with y coordinate of\n\
10083  upper endpoint of error bar. \n\
10084 ";
10085 const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10086 Set FCI (font characterization integer) \n\
10087 \n\
10088 DESCRIPTION:\n\
10089 \n\
10090  Sets font characteristics to be used at the start of the next string\n\
10091  using the FCI approach. See the PLplot documentation for more\n\
10092  information. \n\
10093 \n\
10094  Redacted form: General: plsfci(fci)\n\
10095 \t Perl/PDL: Not available? \n\
10096 \n\
10097 \n\
10098  This function is used in example 23. \n\
10099 \n\
10100 \n\
10101 \n\
10102 SYNOPSIS:\n\
10103 \n\
10104 plsfci(fci)\n\
10105 \n\
10106 ARGUMENTS:\n\
10107 \n\
10108  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10109  of FCI. \n\
10110 ";
10111 const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10112 Select area fill pattern \n\
10113 \n\
10114 DESCRIPTION:\n\
10115 \n\
10116  Select one of eight predefined area fill patterns to use (also see\n\
10117  plpat). Setting the fill style to 0 gives a solid fill. \n\
10118 \n\
10119  Redacted form: plpsty(patt)\n\
10120 \n\
10121  This function is used in examples 12,13,15,16,25. \n\
10122 \n\
10123 \n\
10124 \n\
10125 SYNOPSIS:\n\
10126 \n\
10127 plpsty(patt)\n\
10128 \n\
10129 ARGUMENTS:\n\
10130 \n\
10131  patt (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
10132  horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
10133  consists of lines at 45 degrees angle (upward), and so on. \n\
10134 ";
10135 const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10136 Set symbol size \n\
10137 \n\
10138 DESCRIPTION:\n\
10139 \n\
10140  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10141  plsym. The actual height of a symbol is the product of the default\n\
10142  symbol size and a scaling factor as for the character height. \n\
10143 \n\
10144  Redacted form: plssym(def, scale)\n\
10145 \n\
10146  This function is used in example 29. \n\
10147 \n\
10148 \n\
10149 \n\
10150 SYNOPSIS:\n\
10151 \n\
10152 plssym(def, scale)\n\
10153 \n\
10154 ARGUMENTS:\n\
10155 \n\
10156  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10157  should be set to zero if the default height is to remain\n\
10158  unchanged. \n\
10159 \n\
10160  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10161  actual symbol height. \n\
10162 ";
10163 const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10164 Initialization \n\
10165 \n\
10166 DESCRIPTION:\n\
10167 \n\
10168  Alternative to plstar for initializing the plotting package. The\n\
10169  device name keyword for the desired output device must be supplied as\n\
10170  an argument. These keywords are the same as those printed out by\n\
10171  plstar. If the requested device is not available, or if the input\n\
10172  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10173  is used. This routine also divides the output device page into nx by\n\
10174  ny subpages, each of which may be used independently. The subroutine\n\
10175  pladv is used to advance from one subpage to the next. \n\
10176 \n\
10177  Redacted form: General: plstart(devname, nx, ny)\n\
10178 \t Perl/PDL: plstart(nx, ny, devname)\n\
10179 \n\
10180 \n\
10181  This function is not used in any examples. \n\
10182 \n\
10183 \n\
10184 \n\
10185 SYNOPSIS:\n\
10186 \n\
10187 plstart(devname, nx, ny)\n\
10188 \n\
10189 ARGUMENTS:\n\
10190 \n\
10191  devname (const char *, input) : Device name keyword of the required\n\
10192  output device. If NULL or if the first character is a ``?\'\', the\n\
10193  normal (prompted) start up is used. \n\
10194 \n\
10195  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10196  horizontal direction. \n\
10197 \n\
10198  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10199  vertical direction. \n\
10200 ";
10201 
10202 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10203  PLINT arg1 ;
10204  PLINT *arg2 = (PLINT *) 0 ;
10205  char **arg3 = (char **) 0 ;
10206  Matrix temp1 ;
10207  octave_value_list _out;
10208  octave_value_list *_outp=&_out;
10209  octave_value _outv;
10210 
10211  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10212  SWIG_fail;
10213  }
10214  {
10215  if ( _n_dims( args(0) ) > 1 )
10216  {
10217  error( "argument must be a scalar or vector" ); SWIG_fail;
10218  }
10219  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10220  arg2 = new PLINT[Alen];
10221  temp1 = args(0).matrix_value();
10222  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10223  }
10224  {
10225  charMatrix temp_matrix;
10226  Cell temp_cell;
10227  char *tmp_cstring;
10228  std::string str;
10229  size_t max_length = 0, non_blank_length;
10230  int i, ifcell;
10231  if ( _n_dims( args(1) ) > 2 )
10232  {
10233  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10234  }
10235  if ( !args(1).is_empty() )
10236  {
10237  if ( _dim( args(1), 0 ) != Alen )
10238  {
10239  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10240  }
10241  arg3 = new char*[Alen];
10242  ifcell = args(1).is_cell();
10243  if ( ifcell )
10244  {
10245  temp_cell = args(1).cell_value();
10246  }
10247  else
10248  {
10249  temp_matrix = args(1).char_matrix_value();
10250  // Allow one extra space for null termination.
10251  max_length = _dim( args(1), 1 ) + 1;
10252  }
10253 
10254  for ( i = 0; i < Alen; i++ )
10255  {
10256  // Must copy string to "permanent" location because the string
10257  // location corresponding to tmp_cstring gets
10258  // overwritten for each iteration of loop.
10259  if ( ifcell )
10260  {
10261  if ( temp_cell.elem( i ).is_string() )
10262  {
10263  str = temp_cell.elem( i ).string_value();
10264  // leave room for null termination.
10265  max_length = str.size() + 1;
10266  tmp_cstring = (char *) str.c_str();
10267  }
10268  else
10269  {
10270  // Use null string if user attempts to pass a cell array
10271  // with a non-string element (likely an empty element
10272  // since that should be allowed by the PLplot interface
10273  // if that element is going to be unused).
10274  // leave room for null termination.
10275  max_length = 1;
10276  tmp_cstring = (char *) "";
10277  }
10278  }
10279  else
10280  {
10281  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
10282  }
10283  arg3[i] = new char[max_length];
10284  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10285  arg3[i][max_length - 1] = '\0';
10286  // All the trailing blank crapola should not be needed for
10287  // string cell arrays.
10288  if ( !ifcell )
10289  {
10290  // remove trailing-blank padding that is used by the
10291  // charMatrix class to insure all strings in a given
10292  // charMatrix instance have the same length.
10293  // This transformation also removes legitimate trailing
10294  // blanks but there is nothing we can do about that
10295  // for the charMatrix class.
10296 
10297  // Look for trailing nulls first (just in case, although that
10298  // shouldn't happen if charMatrix implemented as documented)
10299  // before looking for trailing blanks.
10300  non_blank_length = max_length - 2;
10301  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10302  {
10303  non_blank_length--;
10304  }
10305  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10306  {
10307  non_blank_length--;
10308  }
10309  arg3[i][non_blank_length + 1] = '\0';
10310  }
10311  }
10312  }
10313  else
10314  {
10315  arg3 = NULL;
10316  }
10317  }
10318  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10319  _outv = octave_value();
10320  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10321  {
10322  delete [] arg2;
10323  }
10324  {
10325  int i;
10326  if ( arg3 != NULL )
10327  {
10328  for ( i = 0; i < Alen; i++ )
10329  {
10330  delete[] arg3[i];
10331  }
10332  delete[] arg3;
10333  }
10334  }
10335 fail:
10336  return _out;
10337 }
10338 
10339 
10341  int *arg1 = (int *) 0 ;
10342  int *arg2 = (int *) 0 ;
10343  int *arg3 = (int *) 0 ;
10344  char *arg4 = (char *) 0 ;
10345  int *arg5 = (int *) 0 ;
10346  int *arg6 = (int *) 0 ;
10347  PLFLT *arg7 = (PLFLT *) 0 ;
10348  PLFLT *arg8 = (PLFLT *) 0 ;
10349  PLFLT *arg9 = (PLFLT *) 0 ;
10350  PLFLT *arg10 = (PLFLT *) 0 ;
10351  int *arg11 = (int *) 0 ;
10352  int temp1 ;
10353  int res1 = SWIG_TMPOBJ ;
10354  int temp2 ;
10355  int res2 = SWIG_TMPOBJ ;
10356  int temp3 ;
10357  int res3 = SWIG_TMPOBJ ;
10358  octave_value_list retval4 ;
10359  int temp5 ;
10360  int res5 = SWIG_TMPOBJ ;
10361  int temp6 ;
10362  int res6 = SWIG_TMPOBJ ;
10363  PLFLT temp7 ;
10364  int res7 = SWIG_TMPOBJ ;
10365  PLFLT temp8 ;
10366  int res8 = SWIG_TMPOBJ ;
10367  PLFLT temp9 ;
10368  int res9 = SWIG_TMPOBJ ;
10369  PLFLT temp10 ;
10370  int res10 = SWIG_TMPOBJ ;
10371  int temp11 ;
10372  int res11 = SWIG_TMPOBJ ;
10373  octave_value_list _out;
10374  octave_value_list *_outp=&_out;
10375  octave_value _outv;
10376  int result;
10377 
10378  arg1 = &temp1;
10379  arg2 = &temp2;
10380  arg3 = &temp3;
10381  {
10382  // Check if version >= 3.4.0
10383 # if OCTAVE_API_VERSION_NUMBER < 45
10384  retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
10385 # else
10386  retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10387 # endif
10388  arg4 = (char *) retval4( 0 ).char_matrix_value().data();
10389  }
10390  arg5 = &temp5;
10391  arg6 = &temp6;
10392  arg7 = &temp7;
10393  arg8 = &temp8;
10394  arg9 = &temp9;
10395  arg10 = &temp10;
10396  arg11 = &temp11;
10397  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10398  SWIG_fail;
10399  }
10400  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10401  _outv = SWIG_From_int((int)(result));
10402  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10403  if (SWIG_IsTmpObj(res1)) {
10404  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10405  } else {
10406  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10407  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10408  }
10409  if (SWIG_IsTmpObj(res2)) {
10410  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10411  } else {
10412  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10413  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10414  }
10415  if (SWIG_IsTmpObj(res3)) {
10416  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10417  } else {
10418  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10419  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
10420  }
10421  {
10422  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
10423  }
10424  if (SWIG_IsTmpObj(res5)) {
10425  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
10426  } else {
10427  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10428  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
10429  }
10430  if (SWIG_IsTmpObj(res6)) {
10431  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
10432  } else {
10433  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10434  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
10435  }
10436  if (SWIG_IsTmpObj(res7)) {
10437  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
10438  } else {
10439  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10440  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
10441  }
10442  if (SWIG_IsTmpObj(res8)) {
10443  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
10444  } else {
10445  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10446  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
10447  }
10448  if (SWIG_IsTmpObj(res9)) {
10449  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
10450  } else {
10451  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10452  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
10453  }
10454  if (SWIG_IsTmpObj(res10)) {
10455  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
10456  } else {
10457  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10458  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
10459  }
10460  if (SWIG_IsTmpObj(res11)) {
10461  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
10462  } else {
10463  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10464  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
10465  }
10466 fail:
10467  return _out;
10468 }
10469 
10470 
10471 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
10472  PLFLT *arg1 = (PLFLT *) 0 ;
10473  PLFLT *arg2 = (PLFLT *) 0 ;
10474  PLFLT arg3 ;
10475  PLFLT arg4 ;
10476  PLFLT temp1 ;
10477  int res1 = SWIG_TMPOBJ ;
10478  PLFLT temp2 ;
10479  int res2 = SWIG_TMPOBJ ;
10480  double val3 ;
10481  int ecode3 = 0 ;
10482  double val4 ;
10483  int ecode4 = 0 ;
10484  octave_value_list _out;
10485  octave_value_list *_outp=&_out;
10486  octave_value _outv;
10487  int result;
10488 
10489  arg1 = &temp1;
10490  arg2 = &temp2;
10491  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
10492  SWIG_fail;
10493  }
10494  ecode3 = SWIG_AsVal_double(args(0), &val3);
10495  if (!SWIG_IsOK(ecode3)) {
10496  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
10497  }
10498  arg3 = (PLFLT)(val3);
10499  ecode4 = SWIG_AsVal_double(args(1), &val4);
10500  if (!SWIG_IsOK(ecode4)) {
10501  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
10502  }
10503  arg4 = (PLFLT)(val4);
10504  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
10505  _outv = SWIG_From_int((int)(result));
10506  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10507  if (SWIG_IsTmpObj(res1)) {
10508  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
10509  } else {
10510  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10511  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10512  }
10513  if (SWIG_IsTmpObj(res2)) {
10514  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
10515  } else {
10516  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10517  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10518  }
10519 fail:
10520  return _out;
10521 }
10522 
10523 
10524 SWIG_DEFUN( plstripc, _wrap_plstripc, _wrap_plstripc_texinfo ) {
10525  PLINT *arg1 = (PLINT *) 0 ;
10526  char *arg2 = (char *) 0 ;
10527  char *arg3 = (char *) 0 ;
10528  PLFLT arg4 ;
10529  PLFLT arg5 ;
10530  PLFLT arg6 ;
10531  PLFLT arg7 ;
10532  PLFLT arg8 ;
10533  PLFLT arg9 ;
10534  PLFLT arg10 ;
10535  PLBOOL arg11 ;
10536  PLBOOL arg12 ;
10537  PLINT arg13 ;
10538  PLINT arg14 ;
10539  PLINT *arg15 = (PLINT *) 0 ;
10540  PLINT *arg16 = (PLINT *) 0 ;
10541  char *arg17 = (char *) 0 ;
10542  char *arg18 = (char *) 0 ;
10543  char *arg19 = (char *) 0 ;
10544  char *arg20 = (char *) 0 ;
10545  char *arg21 = (char *) 0 ;
10546  char *arg22 = (char *) 0 ;
10547  char *arg23 = (char *) 0 ;
10548  PLINT temp1 ;
10549  int res1 = SWIG_TMPOBJ ;
10550  int res2 ;
10551  char *buf2 = 0 ;
10552  int alloc2 = 0 ;
10553  int res3 ;
10554  char *buf3 = 0 ;
10555  int alloc3 = 0 ;
10556  double val4 ;
10557  int ecode4 = 0 ;
10558  double val5 ;
10559  int ecode5 = 0 ;
10560  double val6 ;
10561  int ecode6 = 0 ;
10562  double val7 ;
10563  int ecode7 = 0 ;
10564  double val8 ;
10565  int ecode8 = 0 ;
10566  double val9 ;
10567  int ecode9 = 0 ;
10568  double val10 ;
10569  int ecode10 = 0 ;
10570  int val11 ;
10571  int ecode11 = 0 ;
10572  int val12 ;
10573  int ecode12 = 0 ;
10574  int val13 ;
10575  int ecode13 = 0 ;
10576  int val14 ;
10577  int ecode14 = 0 ;
10578  Matrix temp15 ;
10579  Matrix temp16 ;
10580  int res17 ;
10581  char *buf17 = 0 ;
10582  int alloc17 = 0 ;
10583  int res18 ;
10584  char *buf18 = 0 ;
10585  int alloc18 = 0 ;
10586  int res19 ;
10587  char *buf19 = 0 ;
10588  int alloc19 = 0 ;
10589  int res20 ;
10590  char *buf20 = 0 ;
10591  int alloc20 = 0 ;
10592  int res21 ;
10593  char *buf21 = 0 ;
10594  int alloc21 = 0 ;
10595  int res22 ;
10596  char *buf22 = 0 ;
10597  int alloc22 = 0 ;
10598  int res23 ;
10599  char *buf23 = 0 ;
10600  int alloc23 = 0 ;
10601  octave_value_list _out;
10602  octave_value_list *_outp=&_out;
10603  octave_value _outv;
10604 
10605  arg1 = &temp1;
10606  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
10607  SWIG_fail;
10608  }
10609  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
10610  if (!SWIG_IsOK(res2)) {
10611  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
10612  }
10613  arg2 = (char *)(buf2);
10614  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
10615  if (!SWIG_IsOK(res3)) {
10616  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
10617  }
10618  arg3 = (char *)(buf3);
10619  ecode4 = SWIG_AsVal_double(args(2), &val4);
10620  if (!SWIG_IsOK(ecode4)) {
10621  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
10622  }
10623  arg4 = (PLFLT)(val4);
10624  ecode5 = SWIG_AsVal_double(args(3), &val5);
10625  if (!SWIG_IsOK(ecode5)) {
10626  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
10627  }
10628  arg5 = (PLFLT)(val5);
10629  ecode6 = SWIG_AsVal_double(args(4), &val6);
10630  if (!SWIG_IsOK(ecode6)) {
10631  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
10632  }
10633  arg6 = (PLFLT)(val6);
10634  ecode7 = SWIG_AsVal_double(args(5), &val7);
10635  if (!SWIG_IsOK(ecode7)) {
10636  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
10637  }
10638  arg7 = (PLFLT)(val7);
10639  ecode8 = SWIG_AsVal_double(args(6), &val8);
10640  if (!SWIG_IsOK(ecode8)) {
10641  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
10642  }
10643  arg8 = (PLFLT)(val8);
10644  ecode9 = SWIG_AsVal_double(args(7), &val9);
10645  if (!SWIG_IsOK(ecode9)) {
10646  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
10647  }
10648  arg9 = (PLFLT)(val9);
10649  ecode10 = SWIG_AsVal_double(args(8), &val10);
10650  if (!SWIG_IsOK(ecode10)) {
10651  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
10652  }
10653  arg10 = (PLFLT)(val10);
10654  ecode11 = SWIG_AsVal_int(args(9), &val11);
10655  if (!SWIG_IsOK(ecode11)) {
10656  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
10657  }
10658  arg11 = (PLBOOL)(val11);
10659  ecode12 = SWIG_AsVal_int(args(10), &val12);
10660  if (!SWIG_IsOK(ecode12)) {
10661  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
10662  }
10663  arg12 = (PLBOOL)(val12);
10664  ecode13 = SWIG_AsVal_int(args(11), &val13);
10665  if (!SWIG_IsOK(ecode13)) {
10666  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
10667  }
10668  arg13 = (PLINT)(val13);
10669  ecode14 = SWIG_AsVal_int(args(12), &val14);
10670  if (!SWIG_IsOK(ecode14)) {
10671  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
10672  }
10673  arg14 = (PLINT)(val14);
10674  {
10675  if ( _n_dims( args(13) ) > 1 )
10676  {
10677  error( "argument must be a scalar or vector" ); SWIG_fail;
10678  }
10679  Alen = (PLINT) ( _dim( args(13), 0 ) );
10680  temp15 = args(13).matrix_value();
10681  arg15 = new PLINT[Alen];
10682  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
10683  }
10684  {
10685  if ( _n_dims( args(14) ) > 1 )
10686  {
10687  error( "argument must be a scalar or vector" ); SWIG_fail;
10688  }
10689  if ( _dim( args(14), 0 ) != Alen )
10690  {
10691  error( "argument vectors must be same length" ); SWIG_fail;
10692  }
10693  temp16 = args(14).matrix_value();
10694  arg16 = new PLINT[Alen];
10695  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
10696  }
10697  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
10698  if (!SWIG_IsOK(res17)) {
10699  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
10700  }
10701  arg17 = (char *)(buf17);
10702  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
10703  if (!SWIG_IsOK(res18)) {
10704  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
10705  }
10706  arg18 = (char *)(buf18);
10707  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
10708  if (!SWIG_IsOK(res19)) {
10709  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
10710  }
10711  arg19 = (char *)(buf19);
10712  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
10713  if (!SWIG_IsOK(res20)) {
10714  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
10715  }
10716  arg20 = (char *)(buf20);
10717  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
10718  if (!SWIG_IsOK(res21)) {
10719  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
10720  }
10721  arg21 = (char *)(buf21);
10722  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
10723  if (!SWIG_IsOK(res22)) {
10724  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
10725  }
10726  arg22 = (char *)(buf22);
10727  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
10728  if (!SWIG_IsOK(res23)) {
10729  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
10730  }
10731  arg23 = (char *)(buf23);
10732  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);
10733  _outv = octave_value();
10734  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10735  if (SWIG_IsTmpObj(res1)) {
10736  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10737  } else {
10738  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10739  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10740  }
10741  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
10742  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
10743  {
10744  delete [] arg15;
10745  }
10746  {
10747  delete [] arg16;
10748  }
10749  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
10750  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
10751  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
10752  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
10753  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
10754  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
10755  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
10756 fail:
10757  return _out;
10758 }
10759 
10760 
10761 SWIG_DEFUN( plcont, _wrap_plcont, _wrap_plcont_texinfo ) {
10762  PLFLT *arg1 = (PLFLT *) 0 ;
10763  PLINT arg2 ;
10764  PLINT arg3 ;
10765  PLINT arg4 ;
10766  PLINT arg5 ;
10767  PLINT arg6 ;
10768  PLINT arg7 ;
10769  PLFLT *arg8 = (PLFLT *) 0 ;
10770  PLINT arg9 ;
10771  PLFLT *arg10 = (PLFLT *) 0 ;
10772  Matrix temp1 ;
10773  int val4 ;
10774  int ecode4 = 0 ;
10775  int val5 ;
10776  int ecode5 = 0 ;
10777  int val6 ;
10778  int ecode6 = 0 ;
10779  int val7 ;
10780  int ecode7 = 0 ;
10781  Matrix temp8 ;
10782  Matrix temp10 ;
10783  octave_value_list _out;
10784  octave_value_list *_outp=&_out;
10785  octave_value _outv;
10786 
10787  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
10788  SWIG_fail;
10789  }
10790  {
10791  if ( _n_dims( args(0) ) > 2 )
10792  {
10793  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10794  }
10795  temp1 = args(0).matrix_value();
10796  arg1 = &temp1( 0, 0 );
10797  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10798  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10799  }
10800  ecode4 = SWIG_AsVal_int(args(1), &val4);
10801  if (!SWIG_IsOK(ecode4)) {
10802  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
10803  }
10804  arg4 = (PLINT)(val4);
10805  ecode5 = SWIG_AsVal_int(args(2), &val5);
10806  if (!SWIG_IsOK(ecode5)) {
10807  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
10808  }
10809  arg5 = (PLINT)(val5);
10810  ecode6 = SWIG_AsVal_int(args(3), &val6);
10811  if (!SWIG_IsOK(ecode6)) {
10812  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
10813  }
10814  arg6 = (PLINT)(val6);
10815  ecode7 = SWIG_AsVal_int(args(4), &val7);
10816  if (!SWIG_IsOK(ecode7)) {
10817  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
10818  }
10819  arg7 = (PLINT)(val7);
10820  {
10821  if ( _n_dims( args(5) ) > 1 )
10822  {
10823  error( "argument must be a scalar or vector" ); SWIG_fail;
10824  }
10825  temp8 = args(5).matrix_value();
10826  arg8 = &temp8( 0, 0 );
10827  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10828  }
10829  {
10830  if ( _n_dims( args(6) ) > 1 )
10831  {
10832  error( "argument must be a scalar or vector" ); SWIG_fail;
10833  }
10834  if ( _dim( args(6), 0 ) != 6 )
10835  {
10836  error( "argument vectors must have length of 6" ); SWIG_fail;
10837  }
10838  temp10 = args(6).matrix_value();
10839  arg10 = &temp10( 0, 0 );
10840  }
10841  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
10842  _outv = octave_value();
10843  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10844  {
10845 
10846  }
10847  {
10848 
10849  }
10850  {
10851 
10852  }
10853 fail:
10854  return _out;
10855 }
10856 
10857 
10858 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
10859  PLFLT *arg1 = (PLFLT *) 0 ;
10860  PLINT arg2 ;
10861  PLINT arg3 ;
10862  PLINT arg4 ;
10863  PLINT arg5 ;
10864  PLINT arg6 ;
10865  PLINT arg7 ;
10866  PLFLT *arg8 = (PLFLT *) 0 ;
10867  PLINT arg9 ;
10868  Matrix temp1 ;
10869  int val4 ;
10870  int ecode4 = 0 ;
10871  int val5 ;
10872  int ecode5 = 0 ;
10873  int val6 ;
10874  int ecode6 = 0 ;
10875  int val7 ;
10876  int ecode7 = 0 ;
10877  Matrix temp8 ;
10878  octave_value_list _out;
10879  octave_value_list *_outp=&_out;
10880  octave_value _outv;
10881 
10882  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
10883  SWIG_fail;
10884  }
10885  {
10886  if ( _n_dims( args(0) ) > 2 )
10887  {
10888  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10889  }
10890  temp1 = args(0).matrix_value();
10891  arg1 = &temp1( 0, 0 );
10892  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10893  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10894  }
10895  ecode4 = SWIG_AsVal_int(args(1), &val4);
10896  if (!SWIG_IsOK(ecode4)) {
10897  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
10898  }
10899  arg4 = (PLINT)(val4);
10900  ecode5 = SWIG_AsVal_int(args(2), &val5);
10901  if (!SWIG_IsOK(ecode5)) {
10902  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
10903  }
10904  arg5 = (PLINT)(val5);
10905  ecode6 = SWIG_AsVal_int(args(3), &val6);
10906  if (!SWIG_IsOK(ecode6)) {
10907  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
10908  }
10909  arg6 = (PLINT)(val6);
10910  ecode7 = SWIG_AsVal_int(args(4), &val7);
10911  if (!SWIG_IsOK(ecode7)) {
10912  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
10913  }
10914  arg7 = (PLINT)(val7);
10915  {
10916  if ( _n_dims( args(5) ) > 1 )
10917  {
10918  error( "argument must be a scalar or vector" ); SWIG_fail;
10919  }
10920  temp8 = args(5).matrix_value();
10921  arg8 = &temp8( 0, 0 );
10922  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10923  }
10924  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
10925  _outv = octave_value();
10926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10927  {
10928 
10929  }
10930  {
10931 
10932  }
10933 fail:
10934  return _out;
10935 }
10936 
10937 
10938 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
10939  PLFLT *arg1 = (PLFLT *) 0 ;
10940  PLINT arg2 ;
10941  PLINT arg3 ;
10942  PLINT arg4 ;
10943  PLINT arg5 ;
10944  PLINT arg6 ;
10945  PLINT arg7 ;
10946  PLFLT *arg8 = (PLFLT *) 0 ;
10947  PLINT arg9 ;
10948  PLFLT *arg10 = (PLFLT *) 0 ;
10949  PLFLT *arg11 = (PLFLT *) 0 ;
10950  Matrix temp1 ;
10951  int val4 ;
10952  int ecode4 = 0 ;
10953  int val5 ;
10954  int ecode5 = 0 ;
10955  int val6 ;
10956  int ecode6 = 0 ;
10957  int val7 ;
10958  int ecode7 = 0 ;
10959  Matrix temp8 ;
10960  Matrix temp10 ;
10961  Matrix temp11 ;
10962  octave_value_list _out;
10963  octave_value_list *_outp=&_out;
10964  octave_value _outv;
10965 
10966  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
10967  SWIG_fail;
10968  }
10969  {
10970  if ( _n_dims( args(0) ) > 2 )
10971  {
10972  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10973  }
10974  temp1 = args(0).matrix_value();
10975  arg1 = &temp1( 0, 0 );
10976  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10977  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10978  }
10979  ecode4 = SWIG_AsVal_int(args(1), &val4);
10980  if (!SWIG_IsOK(ecode4)) {
10981  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
10982  }
10983  arg4 = (PLINT)(val4);
10984  ecode5 = SWIG_AsVal_int(args(2), &val5);
10985  if (!SWIG_IsOK(ecode5)) {
10986  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
10987  }
10988  arg5 = (PLINT)(val5);
10989  ecode6 = SWIG_AsVal_int(args(3), &val6);
10990  if (!SWIG_IsOK(ecode6)) {
10991  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
10992  }
10993  arg6 = (PLINT)(val6);
10994  ecode7 = SWIG_AsVal_int(args(4), &val7);
10995  if (!SWIG_IsOK(ecode7)) {
10996  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
10997  }
10998  arg7 = (PLINT)(val7);
10999  {
11000  if ( _n_dims( args(5) ) > 1 )
11001  {
11002  error( "argument must be a scalar or vector" ); SWIG_fail;
11003  }
11004  temp8 = args(5).matrix_value();
11005  arg8 = &temp8( 0, 0 );
11006  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11007  }
11008  {
11009  if ( _n_dims( args(6) ) > 1 )
11010  {
11011  error( "argument must be a scalar or vector" ); SWIG_fail;
11012  }
11013  if ( _dim( args(6), 0 ) != Xlen )
11014  {
11015  error( "argument vectors must be same length" ); SWIG_fail;
11016  }
11017  temp10 = args(6).matrix_value();
11018  arg10 = &temp10( 0, 0 );
11019  }
11020  {
11021  if ( _n_dims( args(7) ) > 1 )
11022  {
11023  error( "argument must be a scalar or vector" ); SWIG_fail;
11024  }
11025  if ( _dim( args(7), 0 ) != Ylen )
11026  {
11027  error( "argument vectors must be same length" ); SWIG_fail;
11028  }
11029  temp11 = args(7).matrix_value();
11030  arg11 = &temp11( 0, 0 );
11031  }
11032  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11033  _outv = octave_value();
11034  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11035  {
11036 
11037  }
11038  {
11039 
11040  }
11041  {
11042 
11043  }
11044  {
11045 
11046  }
11047 fail:
11048  return _out;
11049 }
11050 
11051 
11052 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11053  PLFLT *arg1 = (PLFLT *) 0 ;
11054  PLINT arg2 ;
11055  PLINT arg3 ;
11056  PLINT arg4 ;
11057  PLINT arg5 ;
11058  PLINT arg6 ;
11059  PLINT arg7 ;
11060  PLFLT *arg8 = (PLFLT *) 0 ;
11061  PLINT arg9 ;
11062  PLFLT *arg10 = (PLFLT *) 0 ;
11063  PLFLT *arg11 = (PLFLT *) 0 ;
11064  Matrix temp1 ;
11065  int val4 ;
11066  int ecode4 = 0 ;
11067  int val5 ;
11068  int ecode5 = 0 ;
11069  int val6 ;
11070  int ecode6 = 0 ;
11071  int val7 ;
11072  int ecode7 = 0 ;
11073  Matrix temp8 ;
11074  Matrix temp10 ;
11075  Matrix temp11 ;
11076  octave_value_list _out;
11077  octave_value_list *_outp=&_out;
11078  octave_value _outv;
11079 
11080  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11081  SWIG_fail;
11082  }
11083  {
11084  if ( _n_dims( args(0) ) > 2 )
11085  {
11086  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11087  }
11088  temp1 = args(0).matrix_value();
11089  arg1 = &temp1( 0, 0 );
11090  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11091  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11092  }
11093  ecode4 = SWIG_AsVal_int(args(1), &val4);
11094  if (!SWIG_IsOK(ecode4)) {
11095  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11096  }
11097  arg4 = (PLINT)(val4);
11098  ecode5 = SWIG_AsVal_int(args(2), &val5);
11099  if (!SWIG_IsOK(ecode5)) {
11100  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11101  }
11102  arg5 = (PLINT)(val5);
11103  ecode6 = SWIG_AsVal_int(args(3), &val6);
11104  if (!SWIG_IsOK(ecode6)) {
11105  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11106  }
11107  arg6 = (PLINT)(val6);
11108  ecode7 = SWIG_AsVal_int(args(4), &val7);
11109  if (!SWIG_IsOK(ecode7)) {
11110  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11111  }
11112  arg7 = (PLINT)(val7);
11113  {
11114  if ( _n_dims( args(5) ) > 1 )
11115  {
11116  error( "argument must be a scalar or vector" ); SWIG_fail;
11117  }
11118  temp8 = args(5).matrix_value();
11119  arg8 = &temp8( 0, 0 );
11120  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11121  }
11122  {
11123  if ( _n_dims( args(6) ) > 2 )
11124  {
11125  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11126  }
11127  if ( _dim( args(6), 0 ) != Xlen )
11128  {
11129  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11130  }
11131  if ( _dim( args(6), 1 ) != Ylen )
11132  {
11133  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11134  }
11135  temp10 = args(6).matrix_value();
11136  arg10 = &temp10( 0, 0 );
11137  }
11138  {
11139  if ( _n_dims( args(7) ) > 2 )
11140  {
11141  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11142  }
11143  if ( _dim( args(7), 0 ) != Xlen )
11144  {
11145  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11146  }
11147  if ( _dim( args(7), 1 ) != Ylen )
11148  {
11149  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11150  }
11151  temp11 = args(7).matrix_value();
11152  arg11 = &temp11( 0, 0 );
11153  }
11154  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11155  _outv = octave_value();
11156  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11157  {
11158 
11159  }
11160  {
11161 
11162  }
11163  {
11164 
11165  }
11166  {
11167 
11168  }
11169 fail:
11170  return _out;
11171 }
11172 
11173 
11174 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11175  PLFLT *arg1 = (PLFLT *) 0 ;
11176  PLINT arg2 ;
11177  PLINT arg3 ;
11178  PLINT arg4 ;
11179  PLINT arg5 ;
11180  PLINT arg6 ;
11181  PLINT arg7 ;
11182  PLFLT *arg8 = (PLFLT *) 0 ;
11183  PLINT arg9 ;
11184  PLFLT *arg10 = (PLFLT *) 0 ;
11185  PLFLT *arg11 = (PLFLT *) 0 ;
11186  Matrix temp1 ;
11187  int val4 ;
11188  int ecode4 = 0 ;
11189  int val5 ;
11190  int ecode5 = 0 ;
11191  int val6 ;
11192  int ecode6 = 0 ;
11193  int val7 ;
11194  int ecode7 = 0 ;
11195  Matrix temp8 ;
11196  Matrix temp10 ;
11197  Matrix temp11 ;
11198  octave_value_list _out;
11199  octave_value_list *_outp=&_out;
11200  octave_value _outv;
11201 
11202  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11203  SWIG_fail;
11204  }
11205  {
11206  if ( _n_dims( args(0) ) > 2 )
11207  {
11208  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11209  }
11210  temp1 = args(0).matrix_value();
11211  arg1 = &temp1( 0, 0 );
11212  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11213  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11214  }
11215  ecode4 = SWIG_AsVal_int(args(1), &val4);
11216  if (!SWIG_IsOK(ecode4)) {
11217  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11218  }
11219  arg4 = (PLINT)(val4);
11220  ecode5 = SWIG_AsVal_int(args(2), &val5);
11221  if (!SWIG_IsOK(ecode5)) {
11222  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11223  }
11224  arg5 = (PLINT)(val5);
11225  ecode6 = SWIG_AsVal_int(args(3), &val6);
11226  if (!SWIG_IsOK(ecode6)) {
11227  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11228  }
11229  arg6 = (PLINT)(val6);
11230  ecode7 = SWIG_AsVal_int(args(4), &val7);
11231  if (!SWIG_IsOK(ecode7)) {
11232  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11233  }
11234  arg7 = (PLINT)(val7);
11235  {
11236  if ( _n_dims( args(5) ) > 1 )
11237  {
11238  error( "argument must be a scalar or vector" ); SWIG_fail;
11239  }
11240  temp8 = args(5).matrix_value();
11241  arg8 = &temp8( 0, 0 );
11242  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11243  }
11244  {
11245  if ( _n_dims( args(6) ) > 2 )
11246  {
11247  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11248  }
11249  if ( _dim( args(6), 0 ) != Xlen )
11250  {
11251  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11252  }
11253  if ( _dim( args(6), 1 ) != Ylen )
11254  {
11255  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11256  }
11257  temp10 = args(6).matrix_value();
11258  arg10 = &temp10( 0, 0 );
11259  }
11260  {
11261  if ( _n_dims( args(7) ) > 2 )
11262  {
11263  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11264  }
11265  if ( _dim( args(7), 0 ) != Xlen )
11266  {
11267  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11268  }
11269  if ( _dim( args(7), 1 ) != Ylen )
11270  {
11271  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11272  }
11273  temp11 = args(7).matrix_value();
11274  arg11 = &temp11( 0, 0 );
11275  }
11276  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11277  _outv = octave_value();
11278  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11279  {
11280 
11281  }
11282  {
11283 
11284  }
11285  {
11286 
11287  }
11288  {
11289 
11290  }
11291 fail:
11292  return _out;
11293 }
11294 
11295 
11296 SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
11297  PLFLT *arg1 = (PLFLT *) 0 ;
11298  PLFLT *arg2 = (PLFLT *) 0 ;
11299  PLFLT *arg3 = (PLFLT *) 0 ;
11300  PLINT arg4 ;
11301  PLFLT *arg5 = (PLFLT *) 0 ;
11302  PLINT arg6 ;
11303  PLFLT *arg7 = (PLFLT *) 0 ;
11304  PLINT arg8 ;
11305  PLFLT *arg9 = (PLFLT *) 0 ;
11306  PLINT arg10 ;
11307  PLFLT arg11 ;
11308  Matrix temp1 ;
11309  Matrix temp2 ;
11310  Matrix temp3 ;
11311  Matrix temp5 ;
11312  Matrix temp7 ;
11313  octave_value_list retval7 ;
11314  int val10 ;
11315  int ecode10 = 0 ;
11316  double val11 ;
11317  int ecode11 = 0 ;
11318  octave_value_list _out;
11319  octave_value_list *_outp=&_out;
11320  octave_value _outv;
11321 
11322  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11323  SWIG_fail;
11324  }
11325  {
11326  if ( _n_dims( args(0) ) > 1 )
11327  {
11328  error( "argument must be a scalar or vector" ); SWIG_fail;
11329  }
11330  Alen = (PLINT) ( _dim( args(0), 0 ) );
11331  temp1 = args(0).matrix_value();
11332  arg1 = &temp1( 0, 0 );
11333  }
11334  {
11335  if ( _n_dims( args(1) ) > 1 )
11336  {
11337  error( "argument must be a scalar or vector" ); SWIG_fail;
11338  }
11339  if ( _dim( args(1), 0 ) != Alen )
11340  {
11341  error( "argument vectors must be same length" ); SWIG_fail;
11342  }
11343  temp2 = args(1).matrix_value();
11344  arg2 = &temp2( 0, 0 );
11345  }
11346  {
11347  if ( _n_dims( args(2) ) > 1 )
11348  {
11349  error( "argument must be a scalar or vector" ); SWIG_fail;
11350  }
11351  if ( _dim( args(2), 0 ) != Alen )
11352  {
11353  error( "argument vectors must be same length" ); SWIG_fail;
11354  }
11355  temp3 = args(2).matrix_value();
11356  arg3 = &temp3( 0, 0 );
11357  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11358  }
11359  {
11360  if ( _n_dims( args(3) ) > 1 )
11361  {
11362  error( "argument must be a scalar or vector" ); SWIG_fail;
11363  }
11364  temp5 = args(3).matrix_value();
11365  arg5 = &temp5( 0, 0 );
11366  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
11367  }
11368  {
11369  if ( _n_dims( args(4) ) > 1 )
11370  {
11371  error( "argument must be a scalar or vector" ); SWIG_fail;
11372  }
11373  temp7 = args(4).matrix_value();
11374  arg7 = &temp7( 0, 0 );
11375  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
11376  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
11377  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11378  }
11379  ecode10 = SWIG_AsVal_int(args(5), &val10);
11380  if (!SWIG_IsOK(ecode10)) {
11381  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
11382  }
11383  arg10 = (PLINT)(val10);
11384  ecode11 = SWIG_AsVal_double(args(6), &val11);
11385  if (!SWIG_IsOK(ecode11)) {
11386  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
11387  }
11388  arg11 = (PLFLT)(val11);
11389  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
11390  _outv = octave_value();
11391  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11392  {
11393  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
11394  }
11395  {
11396 
11397  }
11398  {
11399 
11400  }
11401  {
11402 
11403  }
11404  {
11405 
11406  }
11407  {
11408 
11409  }
11410 fail:
11411  return _out;
11412 }
11413 
11414 
11415 SWIG_DEFUN( plmesh, _wrap_plmesh, _wrap_plmesh_texinfo ) {
11416  PLFLT *arg1 = (PLFLT *) 0 ;
11417  PLFLT *arg2 = (PLFLT *) 0 ;
11418  PLFLT *arg3 = (PLFLT *) 0 ;
11419  PLINT arg4 ;
11420  PLINT arg5 ;
11421  PLINT arg6 ;
11422  Matrix temp1 ;
11423  Matrix temp2 ;
11424  Matrix temp3 ;
11425  int val6 ;
11426  int ecode6 = 0 ;
11427  octave_value_list _out;
11428  octave_value_list *_outp=&_out;
11429  octave_value _outv;
11430 
11431  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
11432  SWIG_fail;
11433  }
11434  {
11435  if ( _n_dims( args(0) ) > 1 )
11436  {
11437  error( "argument must be a scalar or vector" ); SWIG_fail;
11438  }
11439  temp1 = args(0).matrix_value();
11440  arg1 = &temp1( 0, 0 );
11441  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11442  }
11443  {
11444  if ( _n_dims( args(1) ) > 1 )
11445  {
11446  error( "argument must be a scalar or vector" ); SWIG_fail;
11447  }
11448  temp2 = args(1).matrix_value();
11449  arg2 = &temp2( 0, 0 );
11450  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11451  }
11452  {
11453  if ( _n_dims( args(2) ) > 2 )
11454  {
11455  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11456  }
11457  if ( _dim( args(2), 0 ) != Xlen )
11458  {
11459  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11460  }
11461  if ( _dim( args(2), 1 ) != Ylen )
11462  {
11463  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11464  }
11465  temp3 = args(2).matrix_value();
11466  arg3 = &temp3( 0, 0 );
11467  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11468  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11469  }
11470  ecode6 = SWIG_AsVal_int(args(3), &val6);
11471  if (!SWIG_IsOK(ecode6)) {
11472  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
11473  }
11474  arg6 = (PLINT)(val6);
11475  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
11476  _outv = octave_value();
11477  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11478  {
11479 
11480  }
11481  {
11482 
11483  }
11484  {
11485 
11486  }
11487 fail:
11488  return _out;
11489 }
11490 
11491 
11492 SWIG_DEFUN( plmeshc, _wrap_plmeshc, _wrap_plmeshc_texinfo ) {
11493  PLFLT *arg1 = (PLFLT *) 0 ;
11494  PLFLT *arg2 = (PLFLT *) 0 ;
11495  PLFLT *arg3 = (PLFLT *) 0 ;
11496  PLINT arg4 ;
11497  PLINT arg5 ;
11498  PLINT arg6 ;
11499  PLFLT *arg7 = (PLFLT *) 0 ;
11500  PLINT arg8 ;
11501  Matrix temp1 ;
11502  Matrix temp2 ;
11503  Matrix temp3 ;
11504  int val6 ;
11505  int ecode6 = 0 ;
11506  Matrix temp7 ;
11507  octave_value_list _out;
11508  octave_value_list *_outp=&_out;
11509  octave_value _outv;
11510 
11511  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
11512  SWIG_fail;
11513  }
11514  {
11515  if ( _n_dims( args(0) ) > 1 )
11516  {
11517  error( "argument must be a scalar or vector" ); SWIG_fail;
11518  }
11519  temp1 = args(0).matrix_value();
11520  arg1 = &temp1( 0, 0 );
11521  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11522  }
11523  {
11524  if ( _n_dims( args(1) ) > 1 )
11525  {
11526  error( "argument must be a scalar or vector" ); SWIG_fail;
11527  }
11528  temp2 = args(1).matrix_value();
11529  arg2 = &temp2( 0, 0 );
11530  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11531  }
11532  {
11533  if ( _n_dims( args(2) ) > 2 )
11534  {
11535  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11536  }
11537  if ( _dim( args(2), 0 ) != Xlen )
11538  {
11539  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11540  }
11541  if ( _dim( args(2), 1 ) != Ylen )
11542  {
11543  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11544  }
11545  temp3 = args(2).matrix_value();
11546  arg3 = &temp3( 0, 0 );
11547  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11548  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11549  }
11550  ecode6 = SWIG_AsVal_int(args(3), &val6);
11551  if (!SWIG_IsOK(ecode6)) {
11552  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
11553  }
11554  arg6 = (PLINT)(val6);
11555  {
11556  if ( _n_dims( args(4) ) > 1 )
11557  {
11558  error( "argument must be a scalar or vector" ); SWIG_fail;
11559  }
11560  temp7 = args(4).matrix_value();
11561  arg7 = &temp7( 0, 0 );
11562  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11563  }
11564  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11565  _outv = octave_value();
11566  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11567  {
11568 
11569  }
11570  {
11571 
11572  }
11573  {
11574 
11575  }
11576  {
11577 
11578  }
11579 fail:
11580  return _out;
11581 }
11582 
11583 
11584 SWIG_DEFUN( plot3d, _wrap_plot3d, _wrap_plot3d_texinfo ) {
11585  PLFLT *arg1 = (PLFLT *) 0 ;
11586  PLFLT *arg2 = (PLFLT *) 0 ;
11587  PLFLT *arg3 = (PLFLT *) 0 ;
11588  PLINT arg4 ;
11589  PLINT arg5 ;
11590  PLINT arg6 ;
11591  PLBOOL arg7 ;
11592  Matrix temp1 ;
11593  Matrix temp2 ;
11594  Matrix temp3 ;
11595  int val6 ;
11596  int ecode6 = 0 ;
11597  int val7 ;
11598  int ecode7 = 0 ;
11599  octave_value_list _out;
11600  octave_value_list *_outp=&_out;
11601  octave_value _outv;
11602 
11603  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
11604  SWIG_fail;
11605  }
11606  {
11607  if ( _n_dims( args(0) ) > 1 )
11608  {
11609  error( "argument must be a scalar or vector" ); SWIG_fail;
11610  }
11611  temp1 = args(0).matrix_value();
11612  arg1 = &temp1( 0, 0 );
11613  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11614  }
11615  {
11616  if ( _n_dims( args(1) ) > 1 )
11617  {
11618  error( "argument must be a scalar or vector" ); SWIG_fail;
11619  }
11620  temp2 = args(1).matrix_value();
11621  arg2 = &temp2( 0, 0 );
11622  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11623  }
11624  {
11625  if ( _n_dims( args(2) ) > 2 )
11626  {
11627  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11628  }
11629  if ( _dim( args(2), 0 ) != Xlen )
11630  {
11631  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11632  }
11633  if ( _dim( args(2), 1 ) != Ylen )
11634  {
11635  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11636  }
11637  temp3 = args(2).matrix_value();
11638  arg3 = &temp3( 0, 0 );
11639  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11640  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11641  }
11642  ecode6 = SWIG_AsVal_int(args(3), &val6);
11643  if (!SWIG_IsOK(ecode6)) {
11644  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
11645  }
11646  arg6 = (PLINT)(val6);
11647  ecode7 = SWIG_AsVal_int(args(4), &val7);
11648  if (!SWIG_IsOK(ecode7)) {
11649  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
11650  }
11651  arg7 = (PLBOOL)(val7);
11652  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
11653  _outv = octave_value();
11654  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11655  {
11656 
11657  }
11658  {
11659 
11660  }
11661  {
11662 
11663  }
11664 fail:
11665  return _out;
11666 }
11667 
11668 
11669 SWIG_DEFUN( plot3dc, _wrap_plot3dc, _wrap_plot3dc_texinfo ) {
11670  PLFLT *arg1 = (PLFLT *) 0 ;
11671  PLFLT *arg2 = (PLFLT *) 0 ;
11672  PLFLT *arg3 = (PLFLT *) 0 ;
11673  PLINT arg4 ;
11674  PLINT arg5 ;
11675  PLINT arg6 ;
11676  PLFLT *arg7 = (PLFLT *) 0 ;
11677  PLINT arg8 ;
11678  Matrix temp1 ;
11679  Matrix temp2 ;
11680  Matrix temp3 ;
11681  int val6 ;
11682  int ecode6 = 0 ;
11683  Matrix temp7 ;
11684  octave_value_list _out;
11685  octave_value_list *_outp=&_out;
11686  octave_value _outv;
11687 
11688  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
11689  SWIG_fail;
11690  }
11691  {
11692  if ( _n_dims( args(0) ) > 1 )
11693  {
11694  error( "argument must be a scalar or vector" ); SWIG_fail;
11695  }
11696  temp1 = args(0).matrix_value();
11697  arg1 = &temp1( 0, 0 );
11698  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11699  }
11700  {
11701  if ( _n_dims( args(1) ) > 1 )
11702  {
11703  error( "argument must be a scalar or vector" ); SWIG_fail;
11704  }
11705  temp2 = args(1).matrix_value();
11706  arg2 = &temp2( 0, 0 );
11707  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11708  }
11709  {
11710  if ( _n_dims( args(2) ) > 2 )
11711  {
11712  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11713  }
11714  if ( _dim( args(2), 0 ) != Xlen )
11715  {
11716  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11717  }
11718  if ( _dim( args(2), 1 ) != Ylen )
11719  {
11720  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11721  }
11722  temp3 = args(2).matrix_value();
11723  arg3 = &temp3( 0, 0 );
11724  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11725  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11726  }
11727  ecode6 = SWIG_AsVal_int(args(3), &val6);
11728  if (!SWIG_IsOK(ecode6)) {
11729  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
11730  }
11731  arg6 = (PLINT)(val6);
11732  {
11733  if ( _n_dims( args(4) ) > 1 )
11734  {
11735  error( "argument must be a scalar or vector" ); SWIG_fail;
11736  }
11737  temp7 = args(4).matrix_value();
11738  arg7 = &temp7( 0, 0 );
11739  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11740  }
11741  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11742  _outv = octave_value();
11743  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11744  {
11745 
11746  }
11747  {
11748 
11749  }
11750  {
11751 
11752  }
11753  {
11754 
11755  }
11756 fail:
11757  return _out;
11758 }
11759 
11760 
11761 SWIG_DEFUN( plot3dcl, _wrap_plot3dcl, _wrap_plot3dcl_texinfo ) {
11762  PLFLT *arg1 = (PLFLT *) 0 ;
11763  PLFLT *arg2 = (PLFLT *) 0 ;
11764  PLFLT *arg3 = (PLFLT *) 0 ;
11765  PLINT arg4 ;
11766  PLINT arg5 ;
11767  PLINT arg6 ;
11768  PLFLT *arg7 = (PLFLT *) 0 ;
11769  PLINT arg8 ;
11770  PLINT arg9 ;
11771  PLINT arg10 ;
11772  PLINT *arg11 = (PLINT *) 0 ;
11773  PLINT *arg12 = (PLINT *) 0 ;
11774  Matrix temp1 ;
11775  Matrix temp2 ;
11776  Matrix temp3 ;
11777  int val6 ;
11778  int ecode6 = 0 ;
11779  Matrix temp7 ;
11780  int val9 ;
11781  int ecode9 = 0 ;
11782  Matrix temp10 ;
11783  Matrix temp12 ;
11784  octave_value_list _out;
11785  octave_value_list *_outp=&_out;
11786  octave_value _outv;
11787 
11788  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
11789  SWIG_fail;
11790  }
11791  {
11792  if ( _n_dims( args(0) ) > 1 )
11793  {
11794  error( "argument must be a scalar or vector" ); SWIG_fail;
11795  }
11796  temp1 = args(0).matrix_value();
11797  arg1 = &temp1( 0, 0 );
11798  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11799  }
11800  {
11801  if ( _n_dims( args(1) ) > 1 )
11802  {
11803  error( "argument must be a scalar or vector" ); SWIG_fail;
11804  }
11805  temp2 = args(1).matrix_value();
11806  arg2 = &temp2( 0, 0 );
11807  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11808  }
11809  {
11810  if ( _n_dims( args(2) ) > 2 )
11811  {
11812  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11813  }
11814  if ( _dim( args(2), 0 ) != Xlen )
11815  {
11816  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11817  }
11818  if ( _dim( args(2), 1 ) != Ylen )
11819  {
11820  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11821  }
11822  temp3 = args(2).matrix_value();
11823  arg3 = &temp3( 0, 0 );
11824  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11825  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11826  }
11827  ecode6 = SWIG_AsVal_int(args(3), &val6);
11828  if (!SWIG_IsOK(ecode6)) {
11829  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
11830  }
11831  arg6 = (PLINT)(val6);
11832  {
11833  if ( _n_dims( args(4) ) > 1 )
11834  {
11835  error( "argument must be a scalar or vector" ); SWIG_fail;
11836  }
11837  temp7 = args(4).matrix_value();
11838  arg7 = &temp7( 0, 0 );
11839  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11840  }
11841  ecode9 = SWIG_AsVal_int(args(5), &val9);
11842  if (!SWIG_IsOK(ecode9)) {
11843  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
11844  }
11845  arg9 = (PLINT)(val9);
11846  {
11847  if ( _n_dims( args(6) ) > 1 )
11848  {
11849  error( "argument must be a scalar or vector" ); SWIG_fail;
11850  }
11851  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
11852  arg11 = new PLINT[Alen];
11853  temp10 = args(6).matrix_value();
11854  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
11855  }
11856  {
11857  if ( _n_dims( args(7) ) > 1 )
11858  {
11859  error( "argument must be a scalar or vector" ); SWIG_fail;
11860  }
11861  if ( _dim( args(7), 0 ) != Alen )
11862  {
11863  error( "argument vectors must be same length" ); SWIG_fail;
11864  }
11865  temp12 = args(7).matrix_value();
11866  arg12 = new PLINT[Alen];
11867  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
11868  }
11869  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);
11870  _outv = octave_value();
11871  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11872  {
11873 
11874  }
11875  {
11876 
11877  }
11878  {
11879 
11880  }
11881  {
11882 
11883  }
11884  {
11885  delete [] arg11;
11886  }
11887  {
11888  delete [] arg12;
11889  }
11890 fail:
11891  return _out;
11892 }
11893 
11894 
11895 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, _wrap_plsurf3d_texinfo ) {
11896  PLFLT *arg1 = (PLFLT *) 0 ;
11897  PLFLT *arg2 = (PLFLT *) 0 ;
11898  PLFLT *arg3 = (PLFLT *) 0 ;
11899  PLINT arg4 ;
11900  PLINT arg5 ;
11901  PLINT arg6 ;
11902  PLFLT *arg7 = (PLFLT *) 0 ;
11903  PLINT arg8 ;
11904  Matrix temp1 ;
11905  Matrix temp2 ;
11906  Matrix temp3 ;
11907  int val6 ;
11908  int ecode6 = 0 ;
11909  Matrix temp7 ;
11910  octave_value_list _out;
11911  octave_value_list *_outp=&_out;
11912  octave_value _outv;
11913 
11914  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
11915  SWIG_fail;
11916  }
11917  {
11918  if ( _n_dims( args(0) ) > 1 )
11919  {
11920  error( "argument must be a scalar or vector" ); SWIG_fail;
11921  }
11922  temp1 = args(0).matrix_value();
11923  arg1 = &temp1( 0, 0 );
11924  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11925  }
11926  {
11927  if ( _n_dims( args(1) ) > 1 )
11928  {
11929  error( "argument must be a scalar or vector" ); SWIG_fail;
11930  }
11931  temp2 = args(1).matrix_value();
11932  arg2 = &temp2( 0, 0 );
11933  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11934  }
11935  {
11936  if ( _n_dims( args(2) ) > 2 )
11937  {
11938  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11939  }
11940  if ( _dim( args(2), 0 ) != Xlen )
11941  {
11942  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11943  }
11944  if ( _dim( args(2), 1 ) != Ylen )
11945  {
11946  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11947  }
11948  temp3 = args(2).matrix_value();
11949  arg3 = &temp3( 0, 0 );
11950  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11951  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11952  }
11953  ecode6 = SWIG_AsVal_int(args(3), &val6);
11954  if (!SWIG_IsOK(ecode6)) {
11955  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
11956  }
11957  arg6 = (PLINT)(val6);
11958  {
11959  if ( _n_dims( args(4) ) > 1 )
11960  {
11961  error( "argument must be a scalar or vector" ); SWIG_fail;
11962  }
11963  temp7 = args(4).matrix_value();
11964  arg7 = &temp7( 0, 0 );
11965  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11966  }
11967  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11968  _outv = octave_value();
11969  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11970  {
11971 
11972  }
11973  {
11974 
11975  }
11976  {
11977 
11978  }
11979  {
11980 
11981  }
11982 fail:
11983  return _out;
11984 }
11985 
11986 
11987 SWIG_DEFUN( plsurf3dl, _wrap_plsurf3dl, _wrap_plsurf3dl_texinfo ) {
11988  PLFLT *arg1 = (PLFLT *) 0 ;
11989  PLFLT *arg2 = (PLFLT *) 0 ;
11990  PLFLT *arg3 = (PLFLT *) 0 ;
11991  PLINT arg4 ;
11992  PLINT arg5 ;
11993  PLINT arg6 ;
11994  PLFLT *arg7 = (PLFLT *) 0 ;
11995  PLINT arg8 ;
11996  PLINT arg9 ;
11997  PLINT arg10 ;
11998  PLINT *arg11 = (PLINT *) 0 ;
11999  PLINT *arg12 = (PLINT *) 0 ;
12000  Matrix temp1 ;
12001  Matrix temp2 ;
12002  Matrix temp3 ;
12003  int val6 ;
12004  int ecode6 = 0 ;
12005  Matrix temp7 ;
12006  int val9 ;
12007  int ecode9 = 0 ;
12008  Matrix temp10 ;
12009  Matrix temp12 ;
12010  octave_value_list _out;
12011  octave_value_list *_outp=&_out;
12012  octave_value _outv;
12013 
12014  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
12015  SWIG_fail;
12016  }
12017  {
12018  if ( _n_dims( args(0) ) > 1 )
12019  {
12020  error( "argument must be a scalar or vector" ); SWIG_fail;
12021  }
12022  temp1 = args(0).matrix_value();
12023  arg1 = &temp1( 0, 0 );
12024  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12025  }
12026  {
12027  if ( _n_dims( args(1) ) > 1 )
12028  {
12029  error( "argument must be a scalar or vector" ); SWIG_fail;
12030  }
12031  temp2 = args(1).matrix_value();
12032  arg2 = &temp2( 0, 0 );
12033  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12034  }
12035  {
12036  if ( _n_dims( args(2) ) > 2 )
12037  {
12038  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12039  }
12040  if ( _dim( args(2), 0 ) != Xlen )
12041  {
12042  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12043  }
12044  if ( _dim( args(2), 1 ) != Ylen )
12045  {
12046  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12047  }
12048  temp3 = args(2).matrix_value();
12049  arg3 = &temp3( 0, 0 );
12050  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12051  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12052  }
12053  ecode6 = SWIG_AsVal_int(args(3), &val6);
12054  if (!SWIG_IsOK(ecode6)) {
12055  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
12056  }
12057  arg6 = (PLINT)(val6);
12058  {
12059  if ( _n_dims( args(4) ) > 1 )
12060  {
12061  error( "argument must be a scalar or vector" ); SWIG_fail;
12062  }
12063  temp7 = args(4).matrix_value();
12064  arg7 = &temp7( 0, 0 );
12065  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12066  }
12067  ecode9 = SWIG_AsVal_int(args(5), &val9);
12068  if (!SWIG_IsOK(ecode9)) {
12069  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12070  }
12071  arg9 = (PLINT)(val9);
12072  {
12073  if ( _n_dims( args(6) ) > 1 )
12074  {
12075  error( "argument must be a scalar or vector" ); SWIG_fail;
12076  }
12077  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12078  arg11 = new PLINT[Alen];
12079  temp10 = args(6).matrix_value();
12080  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12081  }
12082  {
12083  if ( _n_dims( args(7) ) > 1 )
12084  {
12085  error( "argument must be a scalar or vector" ); SWIG_fail;
12086  }
12087  if ( _dim( args(7), 0 ) != Alen )
12088  {
12089  error( "argument vectors must be same length" ); SWIG_fail;
12090  }
12091  temp12 = args(7).matrix_value();
12092  arg12 = new PLINT[Alen];
12093  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12094  }
12095  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);
12096  _outv = octave_value();
12097  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12098  {
12099 
12100  }
12101  {
12102 
12103  }
12104  {
12105 
12106  }
12107  {
12108 
12109  }
12110  {
12111  delete [] arg11;
12112  }
12113  {
12114  delete [] arg12;
12115  }
12116 fail:
12117  return _out;
12118 }
12119 
12120 
12121 SWIG_DEFUN( plshade, _wrap_plshade, _wrap_plshade_texinfo ) {
12122  PLFLT *arg1 = (PLFLT *) 0 ;
12123  PLINT arg2 ;
12124  PLINT arg3 ;
12125  PLFLT *arg4 = (PLFLT *) 0 ;
12126  PLFLT arg5 ;
12127  PLFLT arg6 ;
12128  PLFLT arg7 ;
12129  PLFLT arg8 ;
12130  PLFLT arg9 ;
12131  PLFLT arg10 ;
12132  PLINT arg11 ;
12133  PLFLT arg12 ;
12134  PLINT arg13 ;
12135  PLINT arg14 ;
12136  PLINT arg15 ;
12137  PLINT arg16 ;
12138  PLINT arg17 ;
12139  PLBOOL arg18 ;
12140  PLFLT *arg19 = (PLFLT *) 0 ;
12141  Matrix temp1 ;
12142  Matrix temp4 ;
12143  double val5 ;
12144  int ecode5 = 0 ;
12145  double val6 ;
12146  int ecode6 = 0 ;
12147  double val7 ;
12148  int ecode7 = 0 ;
12149  double val8 ;
12150  int ecode8 = 0 ;
12151  double val9 ;
12152  int ecode9 = 0 ;
12153  double val10 ;
12154  int ecode10 = 0 ;
12155  int val11 ;
12156  int ecode11 = 0 ;
12157  double val12 ;
12158  int ecode12 = 0 ;
12159  int val13 ;
12160  int ecode13 = 0 ;
12161  int val14 ;
12162  int ecode14 = 0 ;
12163  int val15 ;
12164  int ecode15 = 0 ;
12165  int val16 ;
12166  int ecode16 = 0 ;
12167  int val17 ;
12168  int ecode17 = 0 ;
12169  int val18 ;
12170  int ecode18 = 0 ;
12171  Matrix temp19 ;
12172  octave_value_list _out;
12173  octave_value_list *_outp=&_out;
12174  octave_value _outv;
12175 
12176  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12177  SWIG_fail;
12178  }
12179  {
12180  if ( _n_dims( args(0) ) > 2 )
12181  {
12182  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12183  }
12184  temp1 = args(0).matrix_value();
12185  arg1 = &temp1( 0, 0 );
12186  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12187  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12188  }
12189  {
12190  if ( _n_dims( args(1) ) > 1 )
12191  {
12192  error( "argument must be a scalar or vector" ); SWIG_fail;
12193  }
12194  Alen = (PLINT) ( _dim( args(1), 0 ) );
12195  temp4 = args(1).matrix_value();
12196  arg4 = &temp4( 0, 0 );
12197  }
12198  ecode5 = SWIG_AsVal_double(args(2), &val5);
12199  if (!SWIG_IsOK(ecode5)) {
12200  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12201  }
12202  arg5 = (PLFLT)(val5);
12203  ecode6 = SWIG_AsVal_double(args(3), &val6);
12204  if (!SWIG_IsOK(ecode6)) {
12205  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12206  }
12207  arg6 = (PLFLT)(val6);
12208  ecode7 = SWIG_AsVal_double(args(4), &val7);
12209  if (!SWIG_IsOK(ecode7)) {
12210  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12211  }
12212  arg7 = (PLFLT)(val7);
12213  ecode8 = SWIG_AsVal_double(args(5), &val8);
12214  if (!SWIG_IsOK(ecode8)) {
12215  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12216  }
12217  arg8 = (PLFLT)(val8);
12218  ecode9 = SWIG_AsVal_double(args(6), &val9);
12219  if (!SWIG_IsOK(ecode9)) {
12220  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12221  }
12222  arg9 = (PLFLT)(val9);
12223  ecode10 = SWIG_AsVal_double(args(7), &val10);
12224  if (!SWIG_IsOK(ecode10)) {
12225  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12226  }
12227  arg10 = (PLFLT)(val10);
12228  ecode11 = SWIG_AsVal_int(args(8), &val11);
12229  if (!SWIG_IsOK(ecode11)) {
12230  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12231  }
12232  arg11 = (PLINT)(val11);
12233  ecode12 = SWIG_AsVal_double(args(9), &val12);
12234  if (!SWIG_IsOK(ecode12)) {
12235  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12236  }
12237  arg12 = (PLFLT)(val12);
12238  ecode13 = SWIG_AsVal_int(args(10), &val13);
12239  if (!SWIG_IsOK(ecode13)) {
12240  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
12241  }
12242  arg13 = (PLINT)(val13);
12243  ecode14 = SWIG_AsVal_int(args(11), &val14);
12244  if (!SWIG_IsOK(ecode14)) {
12245  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12246  }
12247  arg14 = (PLINT)(val14);
12248  ecode15 = SWIG_AsVal_int(args(12), &val15);
12249  if (!SWIG_IsOK(ecode15)) {
12250  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
12251  }
12252  arg15 = (PLINT)(val15);
12253  ecode16 = SWIG_AsVal_int(args(13), &val16);
12254  if (!SWIG_IsOK(ecode16)) {
12255  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12256  }
12257  arg16 = (PLINT)(val16);
12258  ecode17 = SWIG_AsVal_int(args(14), &val17);
12259  if (!SWIG_IsOK(ecode17)) {
12260  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
12261  }
12262  arg17 = (PLINT)(val17);
12263  ecode18 = SWIG_AsVal_int(args(15), &val18);
12264  if (!SWIG_IsOK(ecode18)) {
12265  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
12266  }
12267  arg18 = (PLBOOL)(val18);
12268  {
12269  if ( _n_dims( args(16) ) > 1 )
12270  {
12271  error( "argument must be a scalar or vector" ); SWIG_fail;
12272  }
12273  if ( _dim( args(16), 0 ) != 6 )
12274  {
12275  error( "argument vectors must have length of 6" ); SWIG_fail;
12276  }
12277  temp19 = args(16).matrix_value();
12278  arg19 = &temp19( 0, 0 );
12279  }
12280  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);
12281  _outv = octave_value();
12282  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12283  {
12284 
12285  }
12286  {
12287 
12288  }
12289  {
12290 
12291  }
12292 fail:
12293  return _out;
12294 }
12295 
12296 
12297 SWIG_DEFUN( plshade1, _wrap_plshade1, _wrap_plshade1_texinfo ) {
12298  PLFLT *arg1 = (PLFLT *) 0 ;
12299  PLINT arg2 ;
12300  PLINT arg3 ;
12301  char *arg4 = (char *) 0 ;
12302  PLFLT arg5 ;
12303  PLFLT arg6 ;
12304  PLFLT arg7 ;
12305  PLFLT arg8 ;
12306  PLFLT arg9 ;
12307  PLFLT arg10 ;
12308  PLINT arg11 ;
12309  PLFLT arg12 ;
12310  PLINT arg13 ;
12311  PLINT arg14 ;
12312  PLINT arg15 ;
12313  PLINT arg16 ;
12314  PLINT arg17 ;
12315  PLBOOL arg18 ;
12316  PLFLT *arg19 = (PLFLT *) 0 ;
12317  PLFLT *arg20 = (PLFLT *) 0 ;
12318  Matrix temp1 ;
12319  int res4 ;
12320  char *buf4 = 0 ;
12321  int alloc4 = 0 ;
12322  double val5 ;
12323  int ecode5 = 0 ;
12324  double val6 ;
12325  int ecode6 = 0 ;
12326  double val7 ;
12327  int ecode7 = 0 ;
12328  double val8 ;
12329  int ecode8 = 0 ;
12330  double val9 ;
12331  int ecode9 = 0 ;
12332  double val10 ;
12333  int ecode10 = 0 ;
12334  int val11 ;
12335  int ecode11 = 0 ;
12336  double val12 ;
12337  int ecode12 = 0 ;
12338  int val13 ;
12339  int ecode13 = 0 ;
12340  int val14 ;
12341  int ecode14 = 0 ;
12342  int val15 ;
12343  int ecode15 = 0 ;
12344  int val16 ;
12345  int ecode16 = 0 ;
12346  int val17 ;
12347  int ecode17 = 0 ;
12348  int val18 ;
12349  int ecode18 = 0 ;
12350  Matrix temp19 ;
12351  Matrix temp20 ;
12352  octave_value_list _out;
12353  octave_value_list *_outp=&_out;
12354  octave_value _outv;
12355 
12356  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
12357  SWIG_fail;
12358  }
12359  {
12360  if ( _n_dims( args(0) ) > 2 )
12361  {
12362  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12363  }
12364  temp1 = args(0).matrix_value();
12365  arg1 = &temp1( 0, 0 );
12366  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12367  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12368  }
12369  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
12370  if (!SWIG_IsOK(res4)) {
12371  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
12372  }
12373  arg4 = (char *)(buf4);
12374  ecode5 = SWIG_AsVal_double(args(2), &val5);
12375  if (!SWIG_IsOK(ecode5)) {
12376  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
12377  }
12378  arg5 = (PLFLT)(val5);
12379  ecode6 = SWIG_AsVal_double(args(3), &val6);
12380  if (!SWIG_IsOK(ecode6)) {
12381  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
12382  }
12383  arg6 = (PLFLT)(val6);
12384  ecode7 = SWIG_AsVal_double(args(4), &val7);
12385  if (!SWIG_IsOK(ecode7)) {
12386  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
12387  }
12388  arg7 = (PLFLT)(val7);
12389  ecode8 = SWIG_AsVal_double(args(5), &val8);
12390  if (!SWIG_IsOK(ecode8)) {
12391  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
12392  }
12393  arg8 = (PLFLT)(val8);
12394  ecode9 = SWIG_AsVal_double(args(6), &val9);
12395  if (!SWIG_IsOK(ecode9)) {
12396  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
12397  }
12398  arg9 = (PLFLT)(val9);
12399  ecode10 = SWIG_AsVal_double(args(7), &val10);
12400  if (!SWIG_IsOK(ecode10)) {
12401  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
12402  }
12403  arg10 = (PLFLT)(val10);
12404  ecode11 = SWIG_AsVal_int(args(8), &val11);
12405  if (!SWIG_IsOK(ecode11)) {
12406  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
12407  }
12408  arg11 = (PLINT)(val11);
12409  ecode12 = SWIG_AsVal_double(args(9), &val12);
12410  if (!SWIG_IsOK(ecode12)) {
12411  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
12412  }
12413  arg12 = (PLFLT)(val12);
12414  ecode13 = SWIG_AsVal_int(args(10), &val13);
12415  if (!SWIG_IsOK(ecode13)) {
12416  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
12417  }
12418  arg13 = (PLINT)(val13);
12419  ecode14 = SWIG_AsVal_int(args(11), &val14);
12420  if (!SWIG_IsOK(ecode14)) {
12421  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
12422  }
12423  arg14 = (PLINT)(val14);
12424  ecode15 = SWIG_AsVal_int(args(12), &val15);
12425  if (!SWIG_IsOK(ecode15)) {
12426  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
12427  }
12428  arg15 = (PLINT)(val15);
12429  ecode16 = SWIG_AsVal_int(args(13), &val16);
12430  if (!SWIG_IsOK(ecode16)) {
12431  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
12432  }
12433  arg16 = (PLINT)(val16);
12434  ecode17 = SWIG_AsVal_int(args(14), &val17);
12435  if (!SWIG_IsOK(ecode17)) {
12436  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
12437  }
12438  arg17 = (PLINT)(val17);
12439  ecode18 = SWIG_AsVal_int(args(15), &val18);
12440  if (!SWIG_IsOK(ecode18)) {
12441  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
12442  }
12443  arg18 = (PLBOOL)(val18);
12444  {
12445  if ( _n_dims( args(16) ) > 1 )
12446  {
12447  error( "argument must be a scalar or vector" ); SWIG_fail;
12448  }
12449  if ( _dim( args(16), 0 ) != Xlen )
12450  {
12451  error( "argument vectors must be same length" ); SWIG_fail;
12452  }
12453  temp19 = args(16).matrix_value();
12454  arg19 = &temp19( 0, 0 );
12455  }
12456  {
12457  if ( _n_dims( args(17) ) > 1 )
12458  {
12459  error( "argument must be a scalar or vector" ); SWIG_fail;
12460  }
12461  if ( _dim( args(17), 0 ) != Ylen )
12462  {
12463  error( "argument vectors must be same length" ); SWIG_fail;
12464  }
12465  temp20 = args(17).matrix_value();
12466  arg20 = &temp20( 0, 0 );
12467  }
12468  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);
12469  _outv = octave_value();
12470  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12471  {
12472 
12473  }
12474  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12475  {
12476 
12477  }
12478  {
12479 
12480  }
12481 fail:
12482  return _out;
12483 }
12484 
12485 
12486 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
12487  PLFLT *arg1 = (PLFLT *) 0 ;
12488  PLINT arg2 ;
12489  PLINT arg3 ;
12490  char *arg4 = (char *) 0 ;
12491  PLFLT arg5 ;
12492  PLFLT arg6 ;
12493  PLFLT arg7 ;
12494  PLFLT arg8 ;
12495  PLFLT arg9 ;
12496  PLFLT arg10 ;
12497  PLINT arg11 ;
12498  PLFLT arg12 ;
12499  PLINT arg13 ;
12500  PLINT arg14 ;
12501  PLINT arg15 ;
12502  PLINT arg16 ;
12503  PLINT arg17 ;
12504  PLBOOL arg18 ;
12505  PLFLT *arg19 = (PLFLT *) 0 ;
12506  PLFLT *arg20 = (PLFLT *) 0 ;
12507  Matrix temp1 ;
12508  int res4 ;
12509  char *buf4 = 0 ;
12510  int alloc4 = 0 ;
12511  double val5 ;
12512  int ecode5 = 0 ;
12513  double val6 ;
12514  int ecode6 = 0 ;
12515  double val7 ;
12516  int ecode7 = 0 ;
12517  double val8 ;
12518  int ecode8 = 0 ;
12519  double val9 ;
12520  int ecode9 = 0 ;
12521  double val10 ;
12522  int ecode10 = 0 ;
12523  int val11 ;
12524  int ecode11 = 0 ;
12525  double val12 ;
12526  int ecode12 = 0 ;
12527  int val13 ;
12528  int ecode13 = 0 ;
12529  int val14 ;
12530  int ecode14 = 0 ;
12531  int val15 ;
12532  int ecode15 = 0 ;
12533  int val16 ;
12534  int ecode16 = 0 ;
12535  int val17 ;
12536  int ecode17 = 0 ;
12537  int val18 ;
12538  int ecode18 = 0 ;
12539  Matrix temp19 ;
12540  Matrix temp20 ;
12541  octave_value_list _out;
12542  octave_value_list *_outp=&_out;
12543  octave_value _outv;
12544 
12545  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
12546  SWIG_fail;
12547  }
12548  {
12549  if ( _n_dims( args(0) ) > 2 )
12550  {
12551  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12552  }
12553  temp1 = args(0).matrix_value();
12554  arg1 = &temp1( 0, 0 );
12555  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12556  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12557  }
12558  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
12559  if (!SWIG_IsOK(res4)) {
12560  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
12561  }
12562  arg4 = (char *)(buf4);
12563  ecode5 = SWIG_AsVal_double(args(2), &val5);
12564  if (!SWIG_IsOK(ecode5)) {
12565  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
12566  }
12567  arg5 = (PLFLT)(val5);
12568  ecode6 = SWIG_AsVal_double(args(3), &val6);
12569  if (!SWIG_IsOK(ecode6)) {
12570  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
12571  }
12572  arg6 = (PLFLT)(val6);
12573  ecode7 = SWIG_AsVal_double(args(4), &val7);
12574  if (!SWIG_IsOK(ecode7)) {
12575  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
12576  }
12577  arg7 = (PLFLT)(val7);
12578  ecode8 = SWIG_AsVal_double(args(5), &val8);
12579  if (!SWIG_IsOK(ecode8)) {
12580  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
12581  }
12582  arg8 = (PLFLT)(val8);
12583  ecode9 = SWIG_AsVal_double(args(6), &val9);
12584  if (!SWIG_IsOK(ecode9)) {
12585  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
12586  }
12587  arg9 = (PLFLT)(val9);
12588  ecode10 = SWIG_AsVal_double(args(7), &val10);
12589  if (!SWIG_IsOK(ecode10)) {
12590  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
12591  }
12592  arg10 = (PLFLT)(val10);
12593  ecode11 = SWIG_AsVal_int(args(8), &val11);
12594  if (!SWIG_IsOK(ecode11)) {
12595  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
12596  }
12597  arg11 = (PLINT)(val11);
12598  ecode12 = SWIG_AsVal_double(args(9), &val12);
12599  if (!SWIG_IsOK(ecode12)) {
12600  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
12601  }
12602  arg12 = (PLFLT)(val12);
12603  ecode13 = SWIG_AsVal_int(args(10), &val13);
12604  if (!SWIG_IsOK(ecode13)) {
12605  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
12606  }
12607  arg13 = (PLINT)(val13);
12608  ecode14 = SWIG_AsVal_int(args(11), &val14);
12609  if (!SWIG_IsOK(ecode14)) {
12610  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
12611  }
12612  arg14 = (PLINT)(val14);
12613  ecode15 = SWIG_AsVal_int(args(12), &val15);
12614  if (!SWIG_IsOK(ecode15)) {
12615  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
12616  }
12617  arg15 = (PLINT)(val15);
12618  ecode16 = SWIG_AsVal_int(args(13), &val16);
12619  if (!SWIG_IsOK(ecode16)) {
12620  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
12621  }
12622  arg16 = (PLINT)(val16);
12623  ecode17 = SWIG_AsVal_int(args(14), &val17);
12624  if (!SWIG_IsOK(ecode17)) {
12625  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
12626  }
12627  arg17 = (PLINT)(val17);
12628  ecode18 = SWIG_AsVal_int(args(15), &val18);
12629  if (!SWIG_IsOK(ecode18)) {
12630  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
12631  }
12632  arg18 = (PLBOOL)(val18);
12633  {
12634  if ( _n_dims( args(16) ) > 2 )
12635  {
12636  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12637  }
12638  temp19 = args(16).matrix_value();
12639  arg19 = &temp19( 0, 0 );
12640  Xlen = (PLINT) ( _dim( args(16), 0 ) );
12641  Ylen = (PLINT) ( _dim( args(16), 1 ) );
12642  }
12643  {
12644  if ( _n_dims( args(17) ) > 2 )
12645  {
12646  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12647  }
12648  temp20 = args(17).matrix_value();
12649  arg20 = &temp20( 0, 0 );
12650  Xlen = (PLINT) ( _dim( args(17), 0 ) );
12651  Ylen = (PLINT) ( _dim( args(17), 1 ) );
12652  }
12653  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);
12654  _outv = octave_value();
12655  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12656  {
12657 
12658  }
12659  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12660  {
12661 
12662  }
12663  {
12664 
12665  }
12666 fail:
12667  return _out;
12668 }
12669 
12670 
12671 SWIG_DEFUN( plshades, _wrap_plshades, _wrap_plshades_texinfo ) {
12672  PLFLT *arg1 = (PLFLT *) 0 ;
12673  PLINT arg2 ;
12674  PLINT arg3 ;
12675  PLFLT arg4 ;
12676  PLFLT arg5 ;
12677  PLFLT arg6 ;
12678  PLFLT arg7 ;
12679  PLFLT *arg8 = (PLFLT *) 0 ;
12680  PLINT arg9 ;
12681  PLINT arg10 ;
12682  PLINT arg11 ;
12683  PLINT arg12 ;
12684  PLBOOL arg13 ;
12685  Matrix temp1 ;
12686  double val4 ;
12687  int ecode4 = 0 ;
12688  double val5 ;
12689  int ecode5 = 0 ;
12690  double val6 ;
12691  int ecode6 = 0 ;
12692  double val7 ;
12693  int ecode7 = 0 ;
12694  Matrix temp8 ;
12695  int val10 ;
12696  int ecode10 = 0 ;
12697  int val11 ;
12698  int ecode11 = 0 ;
12699  int val12 ;
12700  int ecode12 = 0 ;
12701  int val13 ;
12702  int ecode13 = 0 ;
12703  octave_value_list _out;
12704  octave_value_list *_outp=&_out;
12705  octave_value _outv;
12706 
12707  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
12708  SWIG_fail;
12709  }
12710  {
12711  if ( _n_dims( args(0) ) > 2 )
12712  {
12713  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12714  }
12715  temp1 = args(0).matrix_value();
12716  arg1 = &temp1( 0, 0 );
12717  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12718  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12719  }
12720  ecode4 = SWIG_AsVal_double(args(1), &val4);
12721  if (!SWIG_IsOK(ecode4)) {
12722  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
12723  }
12724  arg4 = (PLFLT)(val4);
12725  ecode5 = SWIG_AsVal_double(args(2), &val5);
12726  if (!SWIG_IsOK(ecode5)) {
12727  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12728  }
12729  arg5 = (PLFLT)(val5);
12730  ecode6 = SWIG_AsVal_double(args(3), &val6);
12731  if (!SWIG_IsOK(ecode6)) {
12732  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12733  }
12734  arg6 = (PLFLT)(val6);
12735  ecode7 = SWIG_AsVal_double(args(4), &val7);
12736  if (!SWIG_IsOK(ecode7)) {
12737  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12738  }
12739  arg7 = (PLFLT)(val7);
12740  {
12741  if ( _n_dims( args(5) ) > 1 )
12742  {
12743  error( "argument must be a scalar or vector" ); SWIG_fail;
12744  }
12745  temp8 = args(5).matrix_value();
12746  arg8 = &temp8( 0, 0 );
12747  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12748  }
12749  ecode10 = SWIG_AsVal_int(args(6), &val10);
12750  if (!SWIG_IsOK(ecode10)) {
12751  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
12752  }
12753  arg10 = (PLINT)(val10);
12754  ecode11 = SWIG_AsVal_int(args(7), &val11);
12755  if (!SWIG_IsOK(ecode11)) {
12756  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
12757  }
12758  arg11 = (PLINT)(val11);
12759  ecode12 = SWIG_AsVal_int(args(8), &val12);
12760  if (!SWIG_IsOK(ecode12)) {
12761  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12762  }
12763  arg12 = (PLINT)(val12);
12764  ecode13 = SWIG_AsVal_int(args(9), &val13);
12765  if (!SWIG_IsOK(ecode13)) {
12766  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
12767  }
12768  arg13 = (PLBOOL)(val13);
12769  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
12770  _outv = octave_value();
12771  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12772  {
12773 
12774  }
12775  {
12776 
12777  }
12778 fail:
12779  return _out;
12780 }
12781 
12782 
12783 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
12784  PLFLT *arg1 = (PLFLT *) 0 ;
12785  PLINT arg2 ;
12786  PLINT arg3 ;
12787  PLFLT arg4 ;
12788  PLFLT arg5 ;
12789  PLFLT arg6 ;
12790  PLFLT arg7 ;
12791  PLFLT *arg8 = (PLFLT *) 0 ;
12792  PLINT arg9 ;
12793  PLINT arg10 ;
12794  PLINT arg11 ;
12795  PLINT arg12 ;
12796  PLBOOL arg13 ;
12797  PLFLT *arg14 = (PLFLT *) 0 ;
12798  Matrix temp1 ;
12799  double val4 ;
12800  int ecode4 = 0 ;
12801  double val5 ;
12802  int ecode5 = 0 ;
12803  double val6 ;
12804  int ecode6 = 0 ;
12805  double val7 ;
12806  int ecode7 = 0 ;
12807  Matrix temp8 ;
12808  int val10 ;
12809  int ecode10 = 0 ;
12810  int val11 ;
12811  int ecode11 = 0 ;
12812  int val12 ;
12813  int ecode12 = 0 ;
12814  int val13 ;
12815  int ecode13 = 0 ;
12816  Matrix temp14 ;
12817  octave_value_list _out;
12818  octave_value_list *_outp=&_out;
12819  octave_value _outv;
12820 
12821  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
12822  SWIG_fail;
12823  }
12824  {
12825  if ( _n_dims( args(0) ) > 2 )
12826  {
12827  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12828  }
12829  temp1 = args(0).matrix_value();
12830  arg1 = &temp1( 0, 0 );
12831  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12832  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12833  }
12834  ecode4 = SWIG_AsVal_double(args(1), &val4);
12835  if (!SWIG_IsOK(ecode4)) {
12836  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
12837  }
12838  arg4 = (PLFLT)(val4);
12839  ecode5 = SWIG_AsVal_double(args(2), &val5);
12840  if (!SWIG_IsOK(ecode5)) {
12841  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
12842  }
12843  arg5 = (PLFLT)(val5);
12844  ecode6 = SWIG_AsVal_double(args(3), &val6);
12845  if (!SWIG_IsOK(ecode6)) {
12846  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
12847  }
12848  arg6 = (PLFLT)(val6);
12849  ecode7 = SWIG_AsVal_double(args(4), &val7);
12850  if (!SWIG_IsOK(ecode7)) {
12851  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
12852  }
12853  arg7 = (PLFLT)(val7);
12854  {
12855  if ( _n_dims( args(5) ) > 1 )
12856  {
12857  error( "argument must be a scalar or vector" ); SWIG_fail;
12858  }
12859  temp8 = args(5).matrix_value();
12860  arg8 = &temp8( 0, 0 );
12861  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12862  }
12863  ecode10 = SWIG_AsVal_int(args(6), &val10);
12864  if (!SWIG_IsOK(ecode10)) {
12865  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
12866  }
12867  arg10 = (PLINT)(val10);
12868  ecode11 = SWIG_AsVal_int(args(7), &val11);
12869  if (!SWIG_IsOK(ecode11)) {
12870  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
12871  }
12872  arg11 = (PLINT)(val11);
12873  ecode12 = SWIG_AsVal_int(args(8), &val12);
12874  if (!SWIG_IsOK(ecode12)) {
12875  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
12876  }
12877  arg12 = (PLINT)(val12);
12878  ecode13 = SWIG_AsVal_int(args(9), &val13);
12879  if (!SWIG_IsOK(ecode13)) {
12880  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
12881  }
12882  arg13 = (PLBOOL)(val13);
12883  {
12884  if ( _n_dims( args(10) ) > 1 )
12885  {
12886  error( "argument must be a scalar or vector" ); SWIG_fail;
12887  }
12888  if ( _dim( args(10), 0 ) != 6 )
12889  {
12890  error( "argument vectors must have length of 6" ); SWIG_fail;
12891  }
12892  temp14 = args(10).matrix_value();
12893  arg14 = &temp14( 0, 0 );
12894  }
12895  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12896  _outv = octave_value();
12897  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12898  {
12899 
12900  }
12901  {
12902 
12903  }
12904  {
12905 
12906  }
12907 fail:
12908  return _out;
12909 }
12910 
12911 
12912 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
12913  PLFLT *arg1 = (PLFLT *) 0 ;
12914  PLINT arg2 ;
12915  PLINT arg3 ;
12916  PLFLT arg4 ;
12917  PLFLT arg5 ;
12918  PLFLT arg6 ;
12919  PLFLT arg7 ;
12920  PLFLT *arg8 = (PLFLT *) 0 ;
12921  PLINT arg9 ;
12922  PLINT arg10 ;
12923  PLINT arg11 ;
12924  PLINT arg12 ;
12925  PLBOOL arg13 ;
12926  PLFLT *arg14 = (PLFLT *) 0 ;
12927  PLFLT *arg15 = (PLFLT *) 0 ;
12928  Matrix temp1 ;
12929  double val4 ;
12930  int ecode4 = 0 ;
12931  double val5 ;
12932  int ecode5 = 0 ;
12933  double val6 ;
12934  int ecode6 = 0 ;
12935  double val7 ;
12936  int ecode7 = 0 ;
12937  Matrix temp8 ;
12938  int val10 ;
12939  int ecode10 = 0 ;
12940  int val11 ;
12941  int ecode11 = 0 ;
12942  int val12 ;
12943  int ecode12 = 0 ;
12944  int val13 ;
12945  int ecode13 = 0 ;
12946  Matrix temp14 ;
12947  Matrix temp15 ;
12948  octave_value_list _out;
12949  octave_value_list *_outp=&_out;
12950  octave_value _outv;
12951 
12952  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
12953  SWIG_fail;
12954  }
12955  {
12956  if ( _n_dims( args(0) ) > 2 )
12957  {
12958  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12959  }
12960  temp1 = args(0).matrix_value();
12961  arg1 = &temp1( 0, 0 );
12962  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12963  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12964  }
12965  ecode4 = SWIG_AsVal_double(args(1), &val4);
12966  if (!SWIG_IsOK(ecode4)) {
12967  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
12968  }
12969  arg4 = (PLFLT)(val4);
12970  ecode5 = SWIG_AsVal_double(args(2), &val5);
12971  if (!SWIG_IsOK(ecode5)) {
12972  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
12973  }
12974  arg5 = (PLFLT)(val5);
12975  ecode6 = SWIG_AsVal_double(args(3), &val6);
12976  if (!SWIG_IsOK(ecode6)) {
12977  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
12978  }
12979  arg6 = (PLFLT)(val6);
12980  ecode7 = SWIG_AsVal_double(args(4), &val7);
12981  if (!SWIG_IsOK(ecode7)) {
12982  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
12983  }
12984  arg7 = (PLFLT)(val7);
12985  {
12986  if ( _n_dims( args(5) ) > 1 )
12987  {
12988  error( "argument must be a scalar or vector" ); SWIG_fail;
12989  }
12990  temp8 = args(5).matrix_value();
12991  arg8 = &temp8( 0, 0 );
12992  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12993  }
12994  ecode10 = SWIG_AsVal_int(args(6), &val10);
12995  if (!SWIG_IsOK(ecode10)) {
12996  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
12997  }
12998  arg10 = (PLINT)(val10);
12999  ecode11 = SWIG_AsVal_int(args(7), &val11);
13000  if (!SWIG_IsOK(ecode11)) {
13001  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
13002  }
13003  arg11 = (PLINT)(val11);
13004  ecode12 = SWIG_AsVal_int(args(8), &val12);
13005  if (!SWIG_IsOK(ecode12)) {
13006  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
13007  }
13008  arg12 = (PLINT)(val12);
13009  ecode13 = SWIG_AsVal_int(args(9), &val13);
13010  if (!SWIG_IsOK(ecode13)) {
13011  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
13012  }
13013  arg13 = (PLBOOL)(val13);
13014  {
13015  if ( _n_dims( args(10) ) > 1 )
13016  {
13017  error( "argument must be a scalar or vector" ); SWIG_fail;
13018  }
13019  if ( _dim( args(10), 0 ) != Xlen )
13020  {
13021  error( "argument vectors must be same length" ); SWIG_fail;
13022  }
13023  temp14 = args(10).matrix_value();
13024  arg14 = &temp14( 0, 0 );
13025  }
13026  {
13027  if ( _n_dims( args(11) ) > 1 )
13028  {
13029  error( "argument must be a scalar or vector" ); SWIG_fail;
13030  }
13031  if ( _dim( args(11), 0 ) != Ylen )
13032  {
13033  error( "argument vectors must be same length" ); SWIG_fail;
13034  }
13035  temp15 = args(11).matrix_value();
13036  arg15 = &temp15( 0, 0 );
13037  }
13038  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);
13039  _outv = octave_value();
13040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13041  {
13042 
13043  }
13044  {
13045 
13046  }
13047  {
13048 
13049  }
13050  {
13051 
13052  }
13053 fail:
13054  return _out;
13055 }
13056 
13057 
13058 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
13059  PLFLT *arg1 = (PLFLT *) 0 ;
13060  PLINT arg2 ;
13061  PLINT arg3 ;
13062  PLFLT arg4 ;
13063  PLFLT arg5 ;
13064  PLFLT arg6 ;
13065  PLFLT arg7 ;
13066  PLFLT *arg8 = (PLFLT *) 0 ;
13067  PLINT arg9 ;
13068  PLINT arg10 ;
13069  PLINT arg11 ;
13070  PLINT arg12 ;
13071  PLBOOL arg13 ;
13072  PLFLT *arg14 = (PLFLT *) 0 ;
13073  PLFLT *arg15 = (PLFLT *) 0 ;
13074  Matrix temp1 ;
13075  double val4 ;
13076  int ecode4 = 0 ;
13077  double val5 ;
13078  int ecode5 = 0 ;
13079  double val6 ;
13080  int ecode6 = 0 ;
13081  double val7 ;
13082  int ecode7 = 0 ;
13083  Matrix temp8 ;
13084  int val10 ;
13085  int ecode10 = 0 ;
13086  int val11 ;
13087  int ecode11 = 0 ;
13088  int val12 ;
13089  int ecode12 = 0 ;
13090  int val13 ;
13091  int ecode13 = 0 ;
13092  Matrix temp14 ;
13093  Matrix temp15 ;
13094  octave_value_list _out;
13095  octave_value_list *_outp=&_out;
13096  octave_value _outv;
13097 
13098  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13099  SWIG_fail;
13100  }
13101  {
13102  if ( _n_dims( args(0) ) > 2 )
13103  {
13104  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13105  }
13106  temp1 = args(0).matrix_value();
13107  arg1 = &temp1( 0, 0 );
13108  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13109  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13110  }
13111  ecode4 = SWIG_AsVal_double(args(1), &val4);
13112  if (!SWIG_IsOK(ecode4)) {
13113  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13114  }
13115  arg4 = (PLFLT)(val4);
13116  ecode5 = SWIG_AsVal_double(args(2), &val5);
13117  if (!SWIG_IsOK(ecode5)) {
13118  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13119  }
13120  arg5 = (PLFLT)(val5);
13121  ecode6 = SWIG_AsVal_double(args(3), &val6);
13122  if (!SWIG_IsOK(ecode6)) {
13123  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13124  }
13125  arg6 = (PLFLT)(val6);
13126  ecode7 = SWIG_AsVal_double(args(4), &val7);
13127  if (!SWIG_IsOK(ecode7)) {
13128  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13129  }
13130  arg7 = (PLFLT)(val7);
13131  {
13132  if ( _n_dims( args(5) ) > 1 )
13133  {
13134  error( "argument must be a scalar or vector" ); SWIG_fail;
13135  }
13136  temp8 = args(5).matrix_value();
13137  arg8 = &temp8( 0, 0 );
13138  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13139  }
13140  ecode10 = SWIG_AsVal_int(args(6), &val10);
13141  if (!SWIG_IsOK(ecode10)) {
13142  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13143  }
13144  arg10 = (PLINT)(val10);
13145  ecode11 = SWIG_AsVal_int(args(7), &val11);
13146  if (!SWIG_IsOK(ecode11)) {
13147  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13148  }
13149  arg11 = (PLINT)(val11);
13150  ecode12 = SWIG_AsVal_int(args(8), &val12);
13151  if (!SWIG_IsOK(ecode12)) {
13152  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13153  }
13154  arg12 = (PLINT)(val12);
13155  ecode13 = SWIG_AsVal_int(args(9), &val13);
13156  if (!SWIG_IsOK(ecode13)) {
13157  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13158  }
13159  arg13 = (PLBOOL)(val13);
13160  {
13161  if ( _n_dims( args(10) ) > 2 )
13162  {
13163  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13164  }
13165  temp14 = args(10).matrix_value();
13166  arg14 = &temp14( 0, 0 );
13167  Xlen = (PLINT) ( _dim( args(10), 0 ) );
13168  Ylen = (PLINT) ( _dim( args(10), 1 ) );
13169  }
13170  {
13171  if ( _n_dims( args(11) ) > 2 )
13172  {
13173  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13174  }
13175  temp15 = args(11).matrix_value();
13176  arg15 = &temp15( 0, 0 );
13177  Xlen = (PLINT) ( _dim( args(11), 0 ) );
13178  Ylen = (PLINT) ( _dim( args(11), 1 ) );
13179  }
13180  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);
13181  _outv = octave_value();
13182  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13183  {
13184 
13185  }
13186  {
13187 
13188  }
13189  {
13190 
13191  }
13192  {
13193 
13194  }
13195 fail:
13196  return _out;
13197 }
13198 
13199 
13200 SWIG_DEFUN( plvect, _wrap_plvect, _wrap_plvect_texinfo ) {
13201  PLFLT *arg1 = (PLFLT *) 0 ;
13202  PLFLT *arg2 = (PLFLT *) 0 ;
13203  PLINT arg3 ;
13204  PLINT arg4 ;
13205  PLFLT arg5 ;
13206  PLFLT *arg6 = (PLFLT *) 0 ;
13207  Matrix temp1 ;
13208  Matrix temp2 ;
13209  double val5 ;
13210  int ecode5 = 0 ;
13211  Matrix temp6 ;
13212  octave_value_list _out;
13213  octave_value_list *_outp=&_out;
13214  octave_value _outv;
13215 
13216  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
13217  SWIG_fail;
13218  }
13219  {
13220  if ( _n_dims( args(0) ) > 2 )
13221  {
13222  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13223  }
13224  temp1 = args(0).matrix_value();
13225  arg1 = &temp1( 0, 0 );
13226  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13227  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13228  }
13229  {
13230  if ( _n_dims( args(1) ) > 2 )
13231  {
13232  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13233  }
13234  if ( _dim( args(1), 0 ) != Xlen )
13235  {
13236  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13237  }
13238  if ( _dim( args(1), 1 ) != Ylen )
13239  {
13240  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13241  }
13242  temp2 = args(1).matrix_value();
13243  arg2 = &temp2( 0, 0 );
13244  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13245  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13246  }
13247  ecode5 = SWIG_AsVal_double(args(2), &val5);
13248  if (!SWIG_IsOK(ecode5)) {
13249  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13250  }
13251  arg5 = (PLFLT)(val5);
13252  {
13253  if ( _n_dims( args(3) ) > 1 )
13254  {
13255  error( "argument must be a scalar or vector" ); SWIG_fail;
13256  }
13257  if ( _dim( args(3), 0 ) != 6 )
13258  {
13259  error( "argument vectors must have length of 6" ); SWIG_fail;
13260  }
13261  temp6 = args(3).matrix_value();
13262  arg6 = &temp6( 0, 0 );
13263  }
13264  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
13265  _outv = octave_value();
13266  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13267  {
13268 
13269  }
13270  {
13271 
13272  }
13273  {
13274 
13275  }
13276 fail:
13277  return _out;
13278 }
13279 
13280 
13281 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
13282  PLFLT *arg1 = (PLFLT *) 0 ;
13283  PLFLT *arg2 = (PLFLT *) 0 ;
13284  PLINT arg3 ;
13285  PLINT arg4 ;
13286  PLFLT arg5 ;
13287  PLFLT *arg6 = (PLFLT *) 0 ;
13288  PLFLT *arg7 = (PLFLT *) 0 ;
13289  Matrix temp1 ;
13290  Matrix temp2 ;
13291  double val5 ;
13292  int ecode5 = 0 ;
13293  Matrix temp6 ;
13294  Matrix temp7 ;
13295  octave_value_list _out;
13296  octave_value_list *_outp=&_out;
13297  octave_value _outv;
13298 
13299  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
13300  SWIG_fail;
13301  }
13302  {
13303  if ( _n_dims( args(0) ) > 2 )
13304  {
13305  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13306  }
13307  temp1 = args(0).matrix_value();
13308  arg1 = &temp1( 0, 0 );
13309  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13310  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13311  }
13312  {
13313  if ( _n_dims( args(1) ) > 2 )
13314  {
13315  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13316  }
13317  if ( _dim( args(1), 0 ) != Xlen )
13318  {
13319  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13320  }
13321  if ( _dim( args(1), 1 ) != Ylen )
13322  {
13323  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13324  }
13325  temp2 = args(1).matrix_value();
13326  arg2 = &temp2( 0, 0 );
13327  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13328  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13329  }
13330  ecode5 = SWIG_AsVal_double(args(2), &val5);
13331  if (!SWIG_IsOK(ecode5)) {
13332  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
13333  }
13334  arg5 = (PLFLT)(val5);
13335  {
13336  if ( _n_dims( args(3) ) > 1 )
13337  {
13338  error( "argument must be a scalar or vector" ); SWIG_fail;
13339  }
13340  if ( _dim( args(3), 0 ) != Xlen )
13341  {
13342  error( "argument vectors must be same length" ); SWIG_fail;
13343  }
13344  temp6 = args(3).matrix_value();
13345  arg6 = &temp6( 0, 0 );
13346  }
13347  {
13348  if ( _n_dims( args(4) ) > 1 )
13349  {
13350  error( "argument must be a scalar or vector" ); SWIG_fail;
13351  }
13352  if ( _dim( args(4), 0 ) != Ylen )
13353  {
13354  error( "argument vectors must be same length" ); SWIG_fail;
13355  }
13356  temp7 = args(4).matrix_value();
13357  arg7 = &temp7( 0, 0 );
13358  }
13359  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
13360  _outv = octave_value();
13361  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13362  {
13363 
13364  }
13365  {
13366 
13367  }
13368  {
13369 
13370  }
13371  {
13372 
13373  }
13374 fail:
13375  return _out;
13376 }
13377 
13378 
13379 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
13380  PLFLT *arg1 = (PLFLT *) 0 ;
13381  PLFLT *arg2 = (PLFLT *) 0 ;
13382  PLINT arg3 ;
13383  PLINT arg4 ;
13384  PLFLT arg5 ;
13385  PLFLT *arg6 = (PLFLT *) 0 ;
13386  PLFLT *arg7 = (PLFLT *) 0 ;
13387  Matrix temp1 ;
13388  Matrix temp2 ;
13389  double val5 ;
13390  int ecode5 = 0 ;
13391  Matrix temp6 ;
13392  Matrix temp7 ;
13393  octave_value_list _out;
13394  octave_value_list *_outp=&_out;
13395  octave_value _outv;
13396 
13397  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
13398  SWIG_fail;
13399  }
13400  {
13401  if ( _n_dims( args(0) ) > 2 )
13402  {
13403  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13404  }
13405  temp1 = args(0).matrix_value();
13406  arg1 = &temp1( 0, 0 );
13407  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13408  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13409  }
13410  {
13411  if ( _n_dims( args(1) ) > 2 )
13412  {
13413  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13414  }
13415  if ( _dim( args(1), 0 ) != Xlen )
13416  {
13417  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13418  }
13419  if ( _dim( args(1), 1 ) != Ylen )
13420  {
13421  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13422  }
13423  temp2 = args(1).matrix_value();
13424  arg2 = &temp2( 0, 0 );
13425  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13426  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13427  }
13428  ecode5 = SWIG_AsVal_double(args(2), &val5);
13429  if (!SWIG_IsOK(ecode5)) {
13430  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
13431  }
13432  arg5 = (PLFLT)(val5);
13433  {
13434  if ( _n_dims( args(3) ) > 2 )
13435  {
13436  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13437  }
13438  temp6 = args(3).matrix_value();
13439  arg6 = &temp6( 0, 0 );
13440  Xlen = (PLINT) ( _dim( args(3), 0 ) );
13441  Ylen = (PLINT) ( _dim( args(3), 1 ) );
13442  }
13443  {
13444  if ( _n_dims( args(4) ) > 2 )
13445  {
13446  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13447  }
13448  temp7 = args(4).matrix_value();
13449  arg7 = &temp7( 0, 0 );
13450  Xlen = (PLINT) ( _dim( args(4), 0 ) );
13451  Ylen = (PLINT) ( _dim( args(4), 1 ) );
13452  }
13453  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
13454  _outv = octave_value();
13455  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13456  {
13457 
13458  }
13459  {
13460 
13461  }
13462  {
13463 
13464  }
13465  {
13466 
13467  }
13468 fail:
13469  return _out;
13470 }
13471 
13472 
13473 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
13474  PLFLT *arg1 = (PLFLT *) 0 ;
13475  PLINT arg2 ;
13476  PLINT arg3 ;
13477  PLFLT arg4 ;
13478  PLFLT arg5 ;
13479  PLFLT arg6 ;
13480  PLFLT arg7 ;
13481  PLFLT arg8 ;
13482  PLFLT arg9 ;
13483  PLFLT arg10 ;
13484  PLFLT arg11 ;
13485  PLFLT arg12 ;
13486  PLFLT arg13 ;
13487  Matrix temp1 ;
13488  double val4 ;
13489  int ecode4 = 0 ;
13490  double val5 ;
13491  int ecode5 = 0 ;
13492  double val6 ;
13493  int ecode6 = 0 ;
13494  double val7 ;
13495  int ecode7 = 0 ;
13496  double val8 ;
13497  int ecode8 = 0 ;
13498  double val9 ;
13499  int ecode9 = 0 ;
13500  double val10 ;
13501  int ecode10 = 0 ;
13502  double val11 ;
13503  int ecode11 = 0 ;
13504  double val12 ;
13505  int ecode12 = 0 ;
13506  double val13 ;
13507  int ecode13 = 0 ;
13508  octave_value_list _out;
13509  octave_value_list *_outp=&_out;
13510  octave_value _outv;
13511 
13512  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
13513  SWIG_fail;
13514  }
13515  {
13516  if ( _n_dims( args(0) ) > 2 )
13517  {
13518  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13519  }
13520  temp1 = args(0).matrix_value();
13521  arg1 = &temp1( 0, 0 );
13522  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13523  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13524  }
13525  ecode4 = SWIG_AsVal_double(args(1), &val4);
13526  if (!SWIG_IsOK(ecode4)) {
13527  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
13528  }
13529  arg4 = (PLFLT)(val4);
13530  ecode5 = SWIG_AsVal_double(args(2), &val5);
13531  if (!SWIG_IsOK(ecode5)) {
13532  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
13533  }
13534  arg5 = (PLFLT)(val5);
13535  ecode6 = SWIG_AsVal_double(args(3), &val6);
13536  if (!SWIG_IsOK(ecode6)) {
13537  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
13538  }
13539  arg6 = (PLFLT)(val6);
13540  ecode7 = SWIG_AsVal_double(args(4), &val7);
13541  if (!SWIG_IsOK(ecode7)) {
13542  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
13543  }
13544  arg7 = (PLFLT)(val7);
13545  ecode8 = SWIG_AsVal_double(args(5), &val8);
13546  if (!SWIG_IsOK(ecode8)) {
13547  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
13548  }
13549  arg8 = (PLFLT)(val8);
13550  ecode9 = SWIG_AsVal_double(args(6), &val9);
13551  if (!SWIG_IsOK(ecode9)) {
13552  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
13553  }
13554  arg9 = (PLFLT)(val9);
13555  ecode10 = SWIG_AsVal_double(args(7), &val10);
13556  if (!SWIG_IsOK(ecode10)) {
13557  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
13558  }
13559  arg10 = (PLFLT)(val10);
13560  ecode11 = SWIG_AsVal_double(args(8), &val11);
13561  if (!SWIG_IsOK(ecode11)) {
13562  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
13563  }
13564  arg11 = (PLFLT)(val11);
13565  ecode12 = SWIG_AsVal_double(args(9), &val12);
13566  if (!SWIG_IsOK(ecode12)) {
13567  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
13568  }
13569  arg12 = (PLFLT)(val12);
13570  ecode13 = SWIG_AsVal_double(args(10), &val13);
13571  if (!SWIG_IsOK(ecode13)) {
13572  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
13573  }
13574  arg13 = (PLFLT)(val13);
13575  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13576  _outv = octave_value();
13577  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13578  {
13579 
13580  }
13581 fail:
13582  return _out;
13583 }
13584 
13585 
13586 SWIG_DEFUN( plimagefr, _wrap_plimagefr, _wrap_plimagefr_texinfo ) {
13587  PLFLT *arg1 = (PLFLT *) 0 ;
13588  PLINT arg2 ;
13589  PLINT arg3 ;
13590  PLFLT arg4 ;
13591  PLFLT arg5 ;
13592  PLFLT arg6 ;
13593  PLFLT arg7 ;
13594  PLFLT arg8 ;
13595  PLFLT arg9 ;
13596  PLFLT arg10 ;
13597  PLFLT arg11 ;
13598  Matrix temp1 ;
13599  double val4 ;
13600  int ecode4 = 0 ;
13601  double val5 ;
13602  int ecode5 = 0 ;
13603  double val6 ;
13604  int ecode6 = 0 ;
13605  double val7 ;
13606  int ecode7 = 0 ;
13607  double val8 ;
13608  int ecode8 = 0 ;
13609  double val9 ;
13610  int ecode9 = 0 ;
13611  double val10 ;
13612  int ecode10 = 0 ;
13613  double val11 ;
13614  int ecode11 = 0 ;
13615  octave_value_list _out;
13616  octave_value_list *_outp=&_out;
13617  octave_value _outv;
13618 
13619  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
13620  SWIG_fail;
13621  }
13622  {
13623  if ( _n_dims( args(0) ) > 2 )
13624  {
13625  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13626  }
13627  temp1 = args(0).matrix_value();
13628  arg1 = &temp1( 0, 0 );
13629  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13630  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13631  }
13632  ecode4 = SWIG_AsVal_double(args(1), &val4);
13633  if (!SWIG_IsOK(ecode4)) {
13634  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
13635  }
13636  arg4 = (PLFLT)(val4);
13637  ecode5 = SWIG_AsVal_double(args(2), &val5);
13638  if (!SWIG_IsOK(ecode5)) {
13639  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
13640  }
13641  arg5 = (PLFLT)(val5);
13642  ecode6 = SWIG_AsVal_double(args(3), &val6);
13643  if (!SWIG_IsOK(ecode6)) {
13644  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
13645  }
13646  arg6 = (PLFLT)(val6);
13647  ecode7 = SWIG_AsVal_double(args(4), &val7);
13648  if (!SWIG_IsOK(ecode7)) {
13649  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
13650  }
13651  arg7 = (PLFLT)(val7);
13652  ecode8 = SWIG_AsVal_double(args(5), &val8);
13653  if (!SWIG_IsOK(ecode8)) {
13654  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
13655  }
13656  arg8 = (PLFLT)(val8);
13657  ecode9 = SWIG_AsVal_double(args(6), &val9);
13658  if (!SWIG_IsOK(ecode9)) {
13659  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
13660  }
13661  arg9 = (PLFLT)(val9);
13662  ecode10 = SWIG_AsVal_double(args(7), &val10);
13663  if (!SWIG_IsOK(ecode10)) {
13664  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
13665  }
13666  arg10 = (PLFLT)(val10);
13667  ecode11 = SWIG_AsVal_double(args(8), &val11);
13668  if (!SWIG_IsOK(ecode11)) {
13669  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
13670  }
13671  arg11 = (PLFLT)(val11);
13672  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13673  _outv = octave_value();
13674  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13675  {
13676 
13677  }
13678 fail:
13679  return _out;
13680 }
13681 
13682 
13683 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
13684  PLFLT *arg1 = (PLFLT *) 0 ;
13685  PLINT arg2 ;
13686  PLINT arg3 ;
13687  PLFLT arg4 ;
13688  PLFLT arg5 ;
13689  PLFLT arg6 ;
13690  PLFLT arg7 ;
13691  PLFLT arg8 ;
13692  PLFLT arg9 ;
13693  PLFLT arg10 ;
13694  PLFLT arg11 ;
13695  PLFLT *arg12 = (PLFLT *) 0 ;
13696  Matrix temp1 ;
13697  double val4 ;
13698  int ecode4 = 0 ;
13699  double val5 ;
13700  int ecode5 = 0 ;
13701  double val6 ;
13702  int ecode6 = 0 ;
13703  double val7 ;
13704  int ecode7 = 0 ;
13705  double val8 ;
13706  int ecode8 = 0 ;
13707  double val9 ;
13708  int ecode9 = 0 ;
13709  double val10 ;
13710  int ecode10 = 0 ;
13711  double val11 ;
13712  int ecode11 = 0 ;
13713  Matrix temp12 ;
13714  octave_value_list _out;
13715  octave_value_list *_outp=&_out;
13716  octave_value _outv;
13717 
13718  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
13719  SWIG_fail;
13720  }
13721  {
13722  if ( _n_dims( args(0) ) > 2 )
13723  {
13724  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13725  }
13726  temp1 = args(0).matrix_value();
13727  arg1 = &temp1( 0, 0 );
13728  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13729  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13730  }
13731  ecode4 = SWIG_AsVal_double(args(1), &val4);
13732  if (!SWIG_IsOK(ecode4)) {
13733  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
13734  }
13735  arg4 = (PLFLT)(val4);
13736  ecode5 = SWIG_AsVal_double(args(2), &val5);
13737  if (!SWIG_IsOK(ecode5)) {
13738  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
13739  }
13740  arg5 = (PLFLT)(val5);
13741  ecode6 = SWIG_AsVal_double(args(3), &val6);
13742  if (!SWIG_IsOK(ecode6)) {
13743  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
13744  }
13745  arg6 = (PLFLT)(val6);
13746  ecode7 = SWIG_AsVal_double(args(4), &val7);
13747  if (!SWIG_IsOK(ecode7)) {
13748  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
13749  }
13750  arg7 = (PLFLT)(val7);
13751  ecode8 = SWIG_AsVal_double(args(5), &val8);
13752  if (!SWIG_IsOK(ecode8)) {
13753  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
13754  }
13755  arg8 = (PLFLT)(val8);
13756  ecode9 = SWIG_AsVal_double(args(6), &val9);
13757  if (!SWIG_IsOK(ecode9)) {
13758  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
13759  }
13760  arg9 = (PLFLT)(val9);
13761  ecode10 = SWIG_AsVal_double(args(7), &val10);
13762  if (!SWIG_IsOK(ecode10)) {
13763  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
13764  }
13765  arg10 = (PLFLT)(val10);
13766  ecode11 = SWIG_AsVal_double(args(8), &val11);
13767  if (!SWIG_IsOK(ecode11)) {
13768  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
13769  }
13770  arg11 = (PLFLT)(val11);
13771  {
13772  if ( _n_dims( args(9) ) > 1 )
13773  {
13774  error( "argument must be a scalar or vector" ); SWIG_fail;
13775  }
13776  if ( _dim( args(9), 0 ) != 6 )
13777  {
13778  error( "argument vectors must have length of 6" ); SWIG_fail;
13779  }
13780  temp12 = args(9).matrix_value();
13781  arg12 = &temp12( 0, 0 );
13782  }
13783  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13784  _outv = octave_value();
13785  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13786  {
13787 
13788  }
13789  {
13790 
13791  }
13792 fail:
13793  return _out;
13794 }
13795 
13796 
13797 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
13798  PLFLT *arg1 = (PLFLT *) 0 ;
13799  PLINT arg2 ;
13800  PLINT arg3 ;
13801  PLFLT arg4 ;
13802  PLFLT arg5 ;
13803  PLFLT arg6 ;
13804  PLFLT arg7 ;
13805  PLFLT arg8 ;
13806  PLFLT arg9 ;
13807  PLFLT arg10 ;
13808  PLFLT arg11 ;
13809  PLFLT *arg12 = (PLFLT *) 0 ;
13810  PLFLT *arg13 = (PLFLT *) 0 ;
13811  Matrix temp1 ;
13812  double val4 ;
13813  int ecode4 = 0 ;
13814  double val5 ;
13815  int ecode5 = 0 ;
13816  double val6 ;
13817  int ecode6 = 0 ;
13818  double val7 ;
13819  int ecode7 = 0 ;
13820  double val8 ;
13821  int ecode8 = 0 ;
13822  double val9 ;
13823  int ecode9 = 0 ;
13824  double val10 ;
13825  int ecode10 = 0 ;
13826  double val11 ;
13827  int ecode11 = 0 ;
13828  Matrix temp12 ;
13829  Matrix temp13 ;
13830  octave_value_list _out;
13831  octave_value_list *_outp=&_out;
13832  octave_value _outv;
13833 
13834  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
13835  SWIG_fail;
13836  }
13837  {
13838  if ( _n_dims( args(0) ) > 2 )
13839  {
13840  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13841  }
13842  temp1 = args(0).matrix_value();
13843  arg1 = &temp1( 0, 0 );
13844  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13845  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13846  }
13847  ecode4 = SWIG_AsVal_double(args(1), &val4);
13848  if (!SWIG_IsOK(ecode4)) {
13849  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
13850  }
13851  arg4 = (PLFLT)(val4);
13852  ecode5 = SWIG_AsVal_double(args(2), &val5);
13853  if (!SWIG_IsOK(ecode5)) {
13854  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
13855  }
13856  arg5 = (PLFLT)(val5);
13857  ecode6 = SWIG_AsVal_double(args(3), &val6);
13858  if (!SWIG_IsOK(ecode6)) {
13859  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
13860  }
13861  arg6 = (PLFLT)(val6);
13862  ecode7 = SWIG_AsVal_double(args(4), &val7);
13863  if (!SWIG_IsOK(ecode7)) {
13864  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
13865  }
13866  arg7 = (PLFLT)(val7);
13867  ecode8 = SWIG_AsVal_double(args(5), &val8);
13868  if (!SWIG_IsOK(ecode8)) {
13869  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
13870  }
13871  arg8 = (PLFLT)(val8);
13872  ecode9 = SWIG_AsVal_double(args(6), &val9);
13873  if (!SWIG_IsOK(ecode9)) {
13874  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
13875  }
13876  arg9 = (PLFLT)(val9);
13877  ecode10 = SWIG_AsVal_double(args(7), &val10);
13878  if (!SWIG_IsOK(ecode10)) {
13879  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
13880  }
13881  arg10 = (PLFLT)(val10);
13882  ecode11 = SWIG_AsVal_double(args(8), &val11);
13883  if (!SWIG_IsOK(ecode11)) {
13884  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
13885  }
13886  arg11 = (PLFLT)(val11);
13887  {
13888  if ( _n_dims( args(9) ) > 1 )
13889  {
13890  error( "argument must be a scalar or vector" ); SWIG_fail;
13891  }
13892  if ( _dim( args(9), 0 ) != Xlen )
13893  {
13894  error( "argument vectors must be same length" ); SWIG_fail;
13895  }
13896  temp12 = args(9).matrix_value();
13897  arg12 = &temp12( 0, 0 );
13898  }
13899  {
13900  if ( _n_dims( args(10) ) > 1 )
13901  {
13902  error( "argument must be a scalar or vector" ); SWIG_fail;
13903  }
13904  if ( _dim( args(10), 0 ) != Ylen )
13905  {
13906  error( "argument vectors must be same length" ); SWIG_fail;
13907  }
13908  temp13 = args(10).matrix_value();
13909  arg13 = &temp13( 0, 0 );
13910  }
13911  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
13912  _outv = octave_value();
13913  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13914  {
13915 
13916  }
13917  {
13918 
13919  }
13920  {
13921 
13922  }
13923 fail:
13924  return _out;
13925 }
13926 
13927 
13928 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
13929  PLFLT *arg1 = (PLFLT *) 0 ;
13930  PLINT arg2 ;
13931  PLINT arg3 ;
13932  PLFLT arg4 ;
13933  PLFLT arg5 ;
13934  PLFLT arg6 ;
13935  PLFLT arg7 ;
13936  PLFLT arg8 ;
13937  PLFLT arg9 ;
13938  PLFLT arg10 ;
13939  PLFLT arg11 ;
13940  PLFLT *arg12 = (PLFLT *) 0 ;
13941  PLFLT *arg13 = (PLFLT *) 0 ;
13942  Matrix temp1 ;
13943  double val4 ;
13944  int ecode4 = 0 ;
13945  double val5 ;
13946  int ecode5 = 0 ;
13947  double val6 ;
13948  int ecode6 = 0 ;
13949  double val7 ;
13950  int ecode7 = 0 ;
13951  double val8 ;
13952  int ecode8 = 0 ;
13953  double val9 ;
13954  int ecode9 = 0 ;
13955  double val10 ;
13956  int ecode10 = 0 ;
13957  double val11 ;
13958  int ecode11 = 0 ;
13959  Matrix temp12 ;
13960  Matrix temp13 ;
13961  octave_value_list _out;
13962  octave_value_list *_outp=&_out;
13963  octave_value _outv;
13964 
13965  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
13966  SWIG_fail;
13967  }
13968  {
13969  if ( _n_dims( args(0) ) > 2 )
13970  {
13971  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13972  }
13973  temp1 = args(0).matrix_value();
13974  arg1 = &temp1( 0, 0 );
13975  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13976  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13977  }
13978  ecode4 = SWIG_AsVal_double(args(1), &val4);
13979  if (!SWIG_IsOK(ecode4)) {
13980  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
13981  }
13982  arg4 = (PLFLT)(val4);
13983  ecode5 = SWIG_AsVal_double(args(2), &val5);
13984  if (!SWIG_IsOK(ecode5)) {
13985  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
13986  }
13987  arg5 = (PLFLT)(val5);
13988  ecode6 = SWIG_AsVal_double(args(3), &val6);
13989  if (!SWIG_IsOK(ecode6)) {
13990  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
13991  }
13992  arg6 = (PLFLT)(val6);
13993  ecode7 = SWIG_AsVal_double(args(4), &val7);
13994  if (!SWIG_IsOK(ecode7)) {
13995  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
13996  }
13997  arg7 = (PLFLT)(val7);
13998  ecode8 = SWIG_AsVal_double(args(5), &val8);
13999  if (!SWIG_IsOK(ecode8)) {
14000  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
14001  }
14002  arg8 = (PLFLT)(val8);
14003  ecode9 = SWIG_AsVal_double(args(6), &val9);
14004  if (!SWIG_IsOK(ecode9)) {
14005  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
14006  }
14007  arg9 = (PLFLT)(val9);
14008  ecode10 = SWIG_AsVal_double(args(7), &val10);
14009  if (!SWIG_IsOK(ecode10)) {
14010  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
14011  }
14012  arg10 = (PLFLT)(val10);
14013  ecode11 = SWIG_AsVal_double(args(8), &val11);
14014  if (!SWIG_IsOK(ecode11)) {
14015  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
14016  }
14017  arg11 = (PLFLT)(val11);
14018  {
14019  if ( _n_dims( args(9) ) > 2 )
14020  {
14021  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14022  }
14023  temp12 = args(9).matrix_value();
14024  arg12 = &temp12( 0, 0 );
14025  Xlen = (PLINT) ( _dim( args(9), 0 ) );
14026  Ylen = (PLINT) ( _dim( args(9), 1 ) );
14027  }
14028  {
14029  if ( _n_dims( args(10) ) > 2 )
14030  {
14031  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14032  }
14033  temp13 = args(10).matrix_value();
14034  arg13 = &temp13( 0, 0 );
14035  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14036  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14037  }
14038  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14039  _outv = octave_value();
14040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14041  {
14042 
14043  }
14044  {
14045 
14046  }
14047  {
14048 
14049  }
14050 fail:
14051  return _out;
14052 }
14053 
14054 
14055 SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
14056  PLFLT *arg1 = (PLFLT *) 0 ;
14057  PLFLT *arg2 = (PLFLT *) 0 ;
14058  PLINT arg3 ;
14059  PLINT arg4 ;
14060  PLFLT arg5 ;
14061  PLFLT arg6 ;
14062  PLFLT arg7 ;
14063  PLFLT arg8 ;
14064  PLINT arg9 ;
14065  PLINT arg10 ;
14066  PLINT arg11 ;
14067  PLFLT arg12 ;
14068  PLFLT arg13 ;
14069  PLINT arg14 ;
14070  PLFLT arg15 ;
14071  PLINT arg16 ;
14072  PLINT *arg17 = (PLINT *) 0 ;
14073  char **arg18 = (char **) 0 ;
14074  PLINT arg19 ;
14075  char **arg20 = (char **) 0 ;
14076  PLFLT *arg21 = (PLFLT *) 0 ;
14077  PLINT *arg22 = (PLINT *) 0 ;
14078  PLINT *arg23 = (PLINT *) 0 ;
14079  PLFLT *arg24 = (PLFLT *) 0 ;
14080  PLFLT temp1 ;
14081  int res1 = SWIG_TMPOBJ ;
14082  PLFLT temp2 ;
14083  int res2 = SWIG_TMPOBJ ;
14084  int val3 ;
14085  int ecode3 = 0 ;
14086  int val4 ;
14087  int ecode4 = 0 ;
14088  double val5 ;
14089  int ecode5 = 0 ;
14090  double val6 ;
14091  int ecode6 = 0 ;
14092  double val7 ;
14093  int ecode7 = 0 ;
14094  double val8 ;
14095  int ecode8 = 0 ;
14096  int val9 ;
14097  int ecode9 = 0 ;
14098  int val10 ;
14099  int ecode10 = 0 ;
14100  int val11 ;
14101  int ecode11 = 0 ;
14102  double val12 ;
14103  int ecode12 = 0 ;
14104  double val13 ;
14105  int ecode13 = 0 ;
14106  int val14 ;
14107  int ecode14 = 0 ;
14108  double val15 ;
14109  int ecode15 = 0 ;
14110  Matrix temp16 ;
14111  Matrix temp21 ;
14112  Matrix temp22 ;
14113  Matrix temp23 ;
14114  Matrix temp24 ;
14115  octave_value_list _out;
14116  octave_value_list *_outp=&_out;
14117  octave_value _outv;
14118 
14119  arg1 = &temp1;
14120  arg2 = &temp2;
14121  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
14122  SWIG_fail;
14123  }
14124  ecode3 = SWIG_AsVal_int(args(0), &val3);
14125  if (!SWIG_IsOK(ecode3)) {
14126  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
14127  }
14128  arg3 = (PLINT)(val3);
14129  ecode4 = SWIG_AsVal_int(args(1), &val4);
14130  if (!SWIG_IsOK(ecode4)) {
14131  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
14132  }
14133  arg4 = (PLINT)(val4);
14134  ecode5 = SWIG_AsVal_double(args(2), &val5);
14135  if (!SWIG_IsOK(ecode5)) {
14136  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
14137  }
14138  arg5 = (PLFLT)(val5);
14139  ecode6 = SWIG_AsVal_double(args(3), &val6);
14140  if (!SWIG_IsOK(ecode6)) {
14141  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
14142  }
14143  arg6 = (PLFLT)(val6);
14144  ecode7 = SWIG_AsVal_double(args(4), &val7);
14145  if (!SWIG_IsOK(ecode7)) {
14146  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
14147  }
14148  arg7 = (PLFLT)(val7);
14149  ecode8 = SWIG_AsVal_double(args(5), &val8);
14150  if (!SWIG_IsOK(ecode8)) {
14151  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
14152  }
14153  arg8 = (PLFLT)(val8);
14154  ecode9 = SWIG_AsVal_int(args(6), &val9);
14155  if (!SWIG_IsOK(ecode9)) {
14156  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
14157  }
14158  arg9 = (PLINT)(val9);
14159  ecode10 = SWIG_AsVal_int(args(7), &val10);
14160  if (!SWIG_IsOK(ecode10)) {
14161  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
14162  }
14163  arg10 = (PLINT)(val10);
14164  ecode11 = SWIG_AsVal_int(args(8), &val11);
14165  if (!SWIG_IsOK(ecode11)) {
14166  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
14167  }
14168  arg11 = (PLINT)(val11);
14169  ecode12 = SWIG_AsVal_double(args(9), &val12);
14170  if (!SWIG_IsOK(ecode12)) {
14171  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
14172  }
14173  arg12 = (PLFLT)(val12);
14174  ecode13 = SWIG_AsVal_double(args(10), &val13);
14175  if (!SWIG_IsOK(ecode13)) {
14176  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
14177  }
14178  arg13 = (PLFLT)(val13);
14179  ecode14 = SWIG_AsVal_int(args(11), &val14);
14180  if (!SWIG_IsOK(ecode14)) {
14181  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
14182  }
14183  arg14 = (PLINT)(val14);
14184  ecode15 = SWIG_AsVal_double(args(12), &val15);
14185  if (!SWIG_IsOK(ecode15)) {
14186  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
14187  }
14188  arg15 = (PLFLT)(val15);
14189  {
14190  if ( _n_dims( args(13) ) > 1 )
14191  {
14192  error( "argument must be a scalar or vector" ); SWIG_fail;
14193  }
14194  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
14195  arg17 = new PLINT[Alen];
14196  temp16 = args(13).matrix_value();
14197  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
14198  }
14199  {
14200  charMatrix temp_matrix;
14201  Cell temp_cell;
14202  char *tmp_cstring;
14203  std::string str;
14204  size_t max_length = 0, non_blank_length;
14205  int i, ifcell;
14206  if ( _n_dims( args(14) ) > 2 )
14207  {
14208  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14209  }
14210  if ( !args(14).is_empty() )
14211  {
14212  if ( _dim( args(14), 0 ) != Alen )
14213  {
14214  error( "first dimension must be same length as previous vector" ); SWIG_fail;
14215  }
14216  arg18 = new char*[Alen];
14217  ifcell = args(14).is_cell();
14218  if ( ifcell )
14219  {
14220  temp_cell = args(14).cell_value();
14221  }
14222  else
14223  {
14224  temp_matrix = args(14).char_matrix_value();
14225  // Allow one extra space for null termination.
14226  max_length = _dim( args(14), 1 ) + 1;
14227  }
14228 
14229  for ( i = 0; i < Alen; i++ )
14230  {
14231  // Must copy string to "permanent" location because the string
14232  // location corresponding to tmp_cstring gets
14233  // overwritten for each iteration of loop.
14234  if ( ifcell )
14235  {
14236  if ( temp_cell.elem( i ).is_string() )
14237  {
14238  str = temp_cell.elem( i ).string_value();
14239  // leave room for null termination.
14240  max_length = str.size() + 1;
14241  tmp_cstring = (char *) str.c_str();
14242  }
14243  else
14244  {
14245  // Use null string if user attempts to pass a cell array
14246  // with a non-string element (likely an empty element
14247  // since that should be allowed by the PLplot interface
14248  // if that element is going to be unused).
14249  // leave room for null termination.
14250  max_length = 1;
14251  tmp_cstring = (char *) "";
14252  }
14253  }
14254  else
14255  {
14256  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14257  }
14258  arg18[i] = new char[max_length];
14259  strncpy( arg18[i], tmp_cstring, max_length - 1 );
14260  arg18[i][max_length - 1] = '\0';
14261  // All the trailing blank crapola should not be needed for
14262  // string cell arrays.
14263  if ( !ifcell )
14264  {
14265  // remove trailing-blank padding that is used by the
14266  // charMatrix class to insure all strings in a given
14267  // charMatrix instance have the same length.
14268  // This transformation also removes legitimate trailing
14269  // blanks but there is nothing we can do about that
14270  // for the charMatrix class.
14271 
14272  // Look for trailing nulls first (just in case, although that
14273  // shouldn't happen if charMatrix implemented as documented)
14274  // before looking for trailing blanks.
14275  non_blank_length = max_length - 2;
14276  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
14277  {
14278  non_blank_length--;
14279  }
14280  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
14281  {
14282  non_blank_length--;
14283  }
14284  arg18[i][non_blank_length + 1] = '\0';
14285  }
14286  }
14287  }
14288  else
14289  {
14290  arg18 = NULL;
14291  }
14292  }
14293  {
14294  charMatrix temp_matrix;
14295  Cell temp_cell;
14296  char *tmp_cstring;
14297  std::string str;
14298  size_t max_length = 0, non_blank_length;
14299  int i, ifcell;
14300  if ( _n_dims( args(15) ) > 2 )
14301  {
14302  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14303  }
14304  if ( !args(15).is_empty() )
14305  {
14306  Alen = _dim( args(15), 0 );
14307  arg19 = Alen;
14308  arg20 = new char*[Alen];
14309  ifcell = args(15).is_cell();
14310  if ( ifcell )
14311  {
14312  temp_cell = args(15).cell_value();
14313  }
14314  else
14315  {
14316  temp_matrix = args(15).char_matrix_value();
14317  // Allow one extra space for null termination.
14318  max_length = _dim( args(15), 1 ) + 1;
14319  }
14320 
14321  for ( i = 0; i < Alen; i++ )
14322  {
14323  // Must copy string to "permanent" location because the string
14324  // location corresponding to tmp_cstring gets
14325  // overwritten for each iteration of loop.
14326  if ( ifcell )
14327  {
14328  if ( temp_cell.elem( i ).is_string() )
14329  {
14330  str = temp_cell.elem( i ).string_value();
14331  // leave room for null termination.
14332  max_length = str.size() + 1;
14333  tmp_cstring = (char *) str.c_str();
14334  }
14335  else
14336  {
14337  // Use null string if user attempts to pass a cell array
14338  // with a non-string element (likely an empty element
14339  // since that should be allowed by the PLplot interface
14340  // if that element is going to be unused).
14341  // leave room for null termination.
14342  max_length = 1;
14343  tmp_cstring = (char *) "";
14344  }
14345  }
14346  else
14347  {
14348  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14349  }
14350  arg20[i] = new char[max_length];
14351  strncpy( arg20[i], tmp_cstring, max_length - 1 );
14352  arg20[i][max_length - 1] = '\0';
14353  // All the trailing blank crapola should not be needed for
14354  // string cell arrays.
14355  if ( !ifcell )
14356  {
14357  // remove trailing-blank padding that is used by the
14358  // charMatrix class to insure all strings in a given
14359  // charMatrix instance have the same length.
14360  // This transformation also removes legitimate trailing
14361  // blanks but there is nothing we can do about that
14362  // for the charMatrix class.
14363 
14364  // Look for trailing nulls first (just in case, although that
14365  // shouldn't happen if charMatrix implemented as documented)
14366  // before looking for trailing blanks.
14367  non_blank_length = max_length - 2;
14368  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
14369  {
14370  non_blank_length--;
14371  }
14372  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
14373  {
14374  non_blank_length--;
14375  }
14376  arg20[i][non_blank_length + 1] = '\0';
14377  }
14378  }
14379  }
14380  else
14381  {
14382  arg19 = 0;
14383  arg20 = NULL;
14384  }
14385  }
14386  {
14387  if ( _n_dims( args(16) ) > 1 )
14388  {
14389  error( "argument must be a scalar or vector" ); SWIG_fail;
14390  }
14391  if ( _dim( args(16), 0 ) != Alen )
14392  {
14393  error( "argument vectors must be same length" ); SWIG_fail;
14394  }
14395  temp21 = args(16).matrix_value();
14396  arg21 = &temp21( 0, 0 );
14397  }
14398  {
14399  if ( _n_dims( args(17) ) > 1 )
14400  {
14401  error( "argument must be a scalar or vector" ); SWIG_fail;
14402  }
14403  if ( _dim( args(17), 0 ) != Alen )
14404  {
14405  error( "argument vectors must be same length" ); SWIG_fail;
14406  }
14407  temp22 = args(17).matrix_value();
14408  arg22 = new PLINT[Alen];
14409  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
14410  }
14411  {
14412  int i;
14413  if ( _n_dims( args(18) ) > 1 )
14414  {
14415  error( "argument must be a scalar or vector" ); SWIG_fail;
14416  }
14417  if ( _dim( args(18), 0 ) != Alen )
14418  {
14419  error( "argument vectors must be same length" ); SWIG_fail;
14420  }
14421  Xlen = Alen;
14422  temp23 = args(18).matrix_value();
14423  arg23 = new PLINT[Alen];
14424  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
14425  Ylen = -1;
14426  for ( i = 0; i < Xlen; i++ )
14427  if ( arg23[i] > Ylen )
14428  Ylen = arg23[i];
14429  }
14430  {
14431  if ( _n_dims( args(19) ) > 2 )
14432  {
14433  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14434  }
14435  if ( _dim( args(19), 0 ) != Xlen )
14436  {
14437  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14438  }
14439  if ( _dim( args(19), 1 ) != Ylen )
14440  {
14441  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14442  }
14443  temp24 = args(19).matrix_value();
14444  arg24 = &temp24( 0, 0 );
14445  }
14446  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);
14447  _outv = octave_value();
14448  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14449  if (SWIG_IsTmpObj(res1)) {
14450  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14451  } else {
14452  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14453  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14454  }
14455  if (SWIG_IsTmpObj(res2)) {
14456  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14457  } else {
14458  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14459  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14460  }
14461  {
14462  delete [] arg17;
14463  }
14464  {
14465  int i;
14466  if ( arg18 != NULL )
14467  {
14468  for ( i = 0; i < Alen; i++ )
14469  {
14470  delete[] arg18[i];
14471  }
14472  delete[] arg18;
14473  }
14474  }
14475  {
14476  int i;
14477  if ( arg20 != NULL )
14478  {
14479  for ( i = 0; i < Alen; i++ )
14480  {
14481  delete[] arg20[i];
14482  }
14483  delete[] arg20;
14484  }
14485  }
14486  {
14487 
14488  }
14489  {
14490  delete [] arg22;
14491  }
14492  {
14493  delete [] arg23;
14494  }
14495  {
14496 
14497  }
14498 fail:
14499  return _out;
14500 }
14501 
14502 
14503 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
14504  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14505  int arg2 ;
14506  void *argp1 = 0 ;
14507  int res1 = 0 ;
14508  int val2 ;
14509  int ecode2 = 0 ;
14510  octave_value_list _out;
14511  octave_value_list *_outp=&_out;
14512  octave_value _outv;
14513 
14514  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
14515  SWIG_fail;
14516  }
14517  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14518  if (!SWIG_IsOK(res1)) {
14519  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14520  }
14521  arg1 = (PLGraphicsIn *)(argp1);
14522  ecode2 = SWIG_AsVal_int(args(1), &val2);
14523  if (!SWIG_IsOK(ecode2)) {
14524  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
14525  }
14526  arg2 = (int)(val2);
14527  if (arg1) (arg1)->type = arg2;
14528  _outv = octave_value();
14529  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14530 fail:
14531  return _out;
14532 }
14533 
14534 
14535 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
14536  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14537  void *argp1 = 0 ;
14538  int res1 = 0 ;
14539  octave_value_list _out;
14540  octave_value_list *_outp=&_out;
14541  octave_value _outv;
14542  int result;
14543 
14544  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
14545  SWIG_fail;
14546  }
14547  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14548  if (!SWIG_IsOK(res1)) {
14549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14550  }
14551  arg1 = (PLGraphicsIn *)(argp1);
14552  result = (int) ((arg1)->type);
14553  _outv = SWIG_From_int((int)(result));
14554  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14555 fail:
14556  return _out;
14557 }
14558 
14559 
14560 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
14561  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14562  unsigned int arg2 ;
14563  void *argp1 = 0 ;
14564  int res1 = 0 ;
14565  unsigned int val2 ;
14566  int ecode2 = 0 ;
14567  octave_value_list _out;
14568  octave_value_list *_outp=&_out;
14569  octave_value _outv;
14570 
14571  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
14572  SWIG_fail;
14573  }
14574  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14575  if (!SWIG_IsOK(res1)) {
14576  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14577  }
14578  arg1 = (PLGraphicsIn *)(argp1);
14579  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14580  if (!SWIG_IsOK(ecode2)) {
14581  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
14582  }
14583  arg2 = (unsigned int)(val2);
14584  if (arg1) (arg1)->state = arg2;
14585  _outv = octave_value();
14586  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14587 fail:
14588  return _out;
14589 }
14590 
14591 
14592 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
14593  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14594  void *argp1 = 0 ;
14595  int res1 = 0 ;
14596  octave_value_list _out;
14597  octave_value_list *_outp=&_out;
14598  octave_value _outv;
14599  unsigned int result;
14600 
14601  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
14602  SWIG_fail;
14603  }
14604  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14605  if (!SWIG_IsOK(res1)) {
14606  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14607  }
14608  arg1 = (PLGraphicsIn *)(argp1);
14609  result = (unsigned int) ((arg1)->state);
14610  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14611  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14612 fail:
14613  return _out;
14614 }
14615 
14616 
14617 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
14618  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14619  unsigned int arg2 ;
14620  void *argp1 = 0 ;
14621  int res1 = 0 ;
14622  unsigned int val2 ;
14623  int ecode2 = 0 ;
14624  octave_value_list _out;
14625  octave_value_list *_outp=&_out;
14626  octave_value _outv;
14627 
14628  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
14629  SWIG_fail;
14630  }
14631  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14632  if (!SWIG_IsOK(res1)) {
14633  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14634  }
14635  arg1 = (PLGraphicsIn *)(argp1);
14636  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14637  if (!SWIG_IsOK(ecode2)) {
14638  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
14639  }
14640  arg2 = (unsigned int)(val2);
14641  if (arg1) (arg1)->keysym = arg2;
14642  _outv = octave_value();
14643  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14644 fail:
14645  return _out;
14646 }
14647 
14648 
14649 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
14650  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14651  void *argp1 = 0 ;
14652  int res1 = 0 ;
14653  octave_value_list _out;
14654  octave_value_list *_outp=&_out;
14655  octave_value _outv;
14656  unsigned int result;
14657 
14658  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
14659  SWIG_fail;
14660  }
14661  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14662  if (!SWIG_IsOK(res1)) {
14663  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14664  }
14665  arg1 = (PLGraphicsIn *)(argp1);
14666  result = (unsigned int) ((arg1)->keysym);
14667  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14668  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14669 fail:
14670  return _out;
14671 }
14672 
14673 
14674 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
14675  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14676  unsigned int arg2 ;
14677  void *argp1 = 0 ;
14678  int res1 = 0 ;
14679  unsigned int val2 ;
14680  int ecode2 = 0 ;
14681  octave_value_list _out;
14682  octave_value_list *_outp=&_out;
14683  octave_value _outv;
14684 
14685  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
14686  SWIG_fail;
14687  }
14688  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14689  if (!SWIG_IsOK(res1)) {
14690  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14691  }
14692  arg1 = (PLGraphicsIn *)(argp1);
14693  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
14694  if (!SWIG_IsOK(ecode2)) {
14695  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
14696  }
14697  arg2 = (unsigned int)(val2);
14698  if (arg1) (arg1)->button = arg2;
14699  _outv = octave_value();
14700  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14701 fail:
14702  return _out;
14703 }
14704 
14705 
14706 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
14707  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14708  void *argp1 = 0 ;
14709  int res1 = 0 ;
14710  octave_value_list _out;
14711  octave_value_list *_outp=&_out;
14712  octave_value _outv;
14713  unsigned int result;
14714 
14715  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
14716  SWIG_fail;
14717  }
14718  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14719  if (!SWIG_IsOK(res1)) {
14720  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14721  }
14722  arg1 = (PLGraphicsIn *)(argp1);
14723  result = (unsigned int) ((arg1)->button);
14724  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
14725  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14726 fail:
14727  return _out;
14728 }
14729 
14730 
14731 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
14732  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14733  PLINT arg2 ;
14734  void *argp1 = 0 ;
14735  int res1 = 0 ;
14736  int val2 ;
14737  int ecode2 = 0 ;
14738  octave_value_list _out;
14739  octave_value_list *_outp=&_out;
14740  octave_value _outv;
14741 
14742  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
14743  SWIG_fail;
14744  }
14745  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14746  if (!SWIG_IsOK(res1)) {
14747  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14748  }
14749  arg1 = (PLGraphicsIn *)(argp1);
14750  ecode2 = SWIG_AsVal_int(args(1), &val2);
14751  if (!SWIG_IsOK(ecode2)) {
14752  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
14753  }
14754  arg2 = (PLINT)(val2);
14755  if (arg1) (arg1)->subwindow = arg2;
14756  _outv = octave_value();
14757  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14758 fail:
14759  return _out;
14760 }
14761 
14762 
14763 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
14764  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14765  void *argp1 = 0 ;
14766  int res1 = 0 ;
14767  octave_value_list _out;
14768  octave_value_list *_outp=&_out;
14769  octave_value _outv;
14770  PLINT result;
14771 
14772  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
14773  SWIG_fail;
14774  }
14775  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14776  if (!SWIG_IsOK(res1)) {
14777  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14778  }
14779  arg1 = (PLGraphicsIn *)(argp1);
14780  result = (PLINT) ((arg1)->subwindow);
14781  _outv = SWIG_From_int((int)(result));
14782  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14783 fail:
14784  return _out;
14785 }
14786 
14787 
14788 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
14789  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14790  char *arg2 ;
14791  void *argp1 = 0 ;
14792  int res1 = 0 ;
14793  char temp2[16] ;
14794  int res2 ;
14795  octave_value_list _out;
14796  octave_value_list *_outp=&_out;
14797  octave_value _outv;
14798 
14799  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
14800  SWIG_fail;
14801  }
14802  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14803  if (!SWIG_IsOK(res1)) {
14804  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14805  }
14806  arg1 = (PLGraphicsIn *)(argp1);
14807  res2 = SWIG_AsCharArray(args(1), temp2, 16);
14808  if (!SWIG_IsOK(res2)) {
14809  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
14810  }
14811  arg2 = (char *)(temp2);
14812  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
14813  else memset(arg1->string,0,16*sizeof(char));
14814  _outv = octave_value();
14815  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14816 fail:
14817  return _out;
14818 }
14819 
14820 
14821 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
14822  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14823  void *argp1 = 0 ;
14824  int res1 = 0 ;
14825  octave_value_list _out;
14826  octave_value_list *_outp=&_out;
14827  octave_value _outv;
14828  char *result = 0 ;
14829 
14830  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
14831  SWIG_fail;
14832  }
14833  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14834  if (!SWIG_IsOK(res1)) {
14835  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14836  }
14837  arg1 = (PLGraphicsIn *)(argp1);
14838  result = (char *)(char *) ((arg1)->string);
14839  {
14840  size_t size = 16;
14841 
14842  while (size && (result[size - 1] == '\0')) --size;
14843 
14844  _outv = SWIG_FromCharPtrAndSize(result, size);
14845  }
14846  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14847 fail:
14848  return _out;
14849 }
14850 
14851 
14852 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
14853  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14854  int arg2 ;
14855  void *argp1 = 0 ;
14856  int res1 = 0 ;
14857  int val2 ;
14858  int ecode2 = 0 ;
14859  octave_value_list _out;
14860  octave_value_list *_outp=&_out;
14861  octave_value _outv;
14862 
14863  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
14864  SWIG_fail;
14865  }
14866  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14867  if (!SWIG_IsOK(res1)) {
14868  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14869  }
14870  arg1 = (PLGraphicsIn *)(argp1);
14871  ecode2 = SWIG_AsVal_int(args(1), &val2);
14872  if (!SWIG_IsOK(ecode2)) {
14873  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
14874  }
14875  arg2 = (int)(val2);
14876  if (arg1) (arg1)->pX = arg2;
14877  _outv = octave_value();
14878  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14879 fail:
14880  return _out;
14881 }
14882 
14883 
14884 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
14885  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14886  void *argp1 = 0 ;
14887  int res1 = 0 ;
14888  octave_value_list _out;
14889  octave_value_list *_outp=&_out;
14890  octave_value _outv;
14891  int result;
14892 
14893  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
14894  SWIG_fail;
14895  }
14896  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14897  if (!SWIG_IsOK(res1)) {
14898  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14899  }
14900  arg1 = (PLGraphicsIn *)(argp1);
14901  result = (int) ((arg1)->pX);
14902  _outv = SWIG_From_int((int)(result));
14903  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14904 fail:
14905  return _out;
14906 }
14907 
14908 
14909 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
14910  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14911  int arg2 ;
14912  void *argp1 = 0 ;
14913  int res1 = 0 ;
14914  int val2 ;
14915  int ecode2 = 0 ;
14916  octave_value_list _out;
14917  octave_value_list *_outp=&_out;
14918  octave_value _outv;
14919 
14920  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
14921  SWIG_fail;
14922  }
14923  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14924  if (!SWIG_IsOK(res1)) {
14925  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14926  }
14927  arg1 = (PLGraphicsIn *)(argp1);
14928  ecode2 = SWIG_AsVal_int(args(1), &val2);
14929  if (!SWIG_IsOK(ecode2)) {
14930  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
14931  }
14932  arg2 = (int)(val2);
14933  if (arg1) (arg1)->pY = arg2;
14934  _outv = octave_value();
14935  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14936 fail:
14937  return _out;
14938 }
14939 
14940 
14941 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
14942  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14943  void *argp1 = 0 ;
14944  int res1 = 0 ;
14945  octave_value_list _out;
14946  octave_value_list *_outp=&_out;
14947  octave_value _outv;
14948  int result;
14949 
14950  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
14951  SWIG_fail;
14952  }
14953  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14954  if (!SWIG_IsOK(res1)) {
14955  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14956  }
14957  arg1 = (PLGraphicsIn *)(argp1);
14958  result = (int) ((arg1)->pY);
14959  _outv = SWIG_From_int((int)(result));
14960  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14961 fail:
14962  return _out;
14963 }
14964 
14965 
14966 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
14967  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14968  PLFLT arg2 ;
14969  void *argp1 = 0 ;
14970  int res1 = 0 ;
14971  double val2 ;
14972  int ecode2 = 0 ;
14973  octave_value_list _out;
14974  octave_value_list *_outp=&_out;
14975  octave_value _outv;
14976 
14977  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
14978  SWIG_fail;
14979  }
14980  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14981  if (!SWIG_IsOK(res1)) {
14982  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14983  }
14984  arg1 = (PLGraphicsIn *)(argp1);
14985  ecode2 = SWIG_AsVal_double(args(1), &val2);
14986  if (!SWIG_IsOK(ecode2)) {
14987  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
14988  }
14989  arg2 = (PLFLT)(val2);
14990  if (arg1) (arg1)->dX = arg2;
14991  _outv = octave_value();
14992  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14993 fail:
14994  return _out;
14995 }
14996 
14997 
14998 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
14999  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15000  void *argp1 = 0 ;
15001  int res1 = 0 ;
15002  octave_value_list _out;
15003  octave_value_list *_outp=&_out;
15004  octave_value _outv;
15005  PLFLT result;
15006 
15007  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
15008  SWIG_fail;
15009  }
15010  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15011  if (!SWIG_IsOK(res1)) {
15012  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15013  }
15014  arg1 = (PLGraphicsIn *)(argp1);
15015  result = (PLFLT) ((arg1)->dX);
15016  _outv = SWIG_From_double((double)(result));
15017  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15018 fail:
15019  return _out;
15020 }
15021 
15022 
15023 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
15024  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15025  PLFLT arg2 ;
15026  void *argp1 = 0 ;
15027  int res1 = 0 ;
15028  double val2 ;
15029  int ecode2 = 0 ;
15030  octave_value_list _out;
15031  octave_value_list *_outp=&_out;
15032  octave_value _outv;
15033 
15034  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
15035  SWIG_fail;
15036  }
15037  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15038  if (!SWIG_IsOK(res1)) {
15039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15040  }
15041  arg1 = (PLGraphicsIn *)(argp1);
15042  ecode2 = SWIG_AsVal_double(args(1), &val2);
15043  if (!SWIG_IsOK(ecode2)) {
15044  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
15045  }
15046  arg2 = (PLFLT)(val2);
15047  if (arg1) (arg1)->dY = arg2;
15048  _outv = octave_value();
15049  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15050 fail:
15051  return _out;
15052 }
15053 
15054 
15055 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
15056  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15057  void *argp1 = 0 ;
15058  int res1 = 0 ;
15059  octave_value_list _out;
15060  octave_value_list *_outp=&_out;
15061  octave_value _outv;
15062  PLFLT result;
15063 
15064  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
15065  SWIG_fail;
15066  }
15067  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15068  if (!SWIG_IsOK(res1)) {
15069  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15070  }
15071  arg1 = (PLGraphicsIn *)(argp1);
15072  result = (PLFLT) ((arg1)->dY);
15073  _outv = SWIG_From_double((double)(result));
15074  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15075 fail:
15076  return _out;
15077 }
15078 
15079 
15080 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
15081  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15082  PLFLT arg2 ;
15083  void *argp1 = 0 ;
15084  int res1 = 0 ;
15085  double val2 ;
15086  int ecode2 = 0 ;
15087  octave_value_list _out;
15088  octave_value_list *_outp=&_out;
15089  octave_value _outv;
15090 
15091  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
15092  SWIG_fail;
15093  }
15094  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15095  if (!SWIG_IsOK(res1)) {
15096  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15097  }
15098  arg1 = (PLGraphicsIn *)(argp1);
15099  ecode2 = SWIG_AsVal_double(args(1), &val2);
15100  if (!SWIG_IsOK(ecode2)) {
15101  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
15102  }
15103  arg2 = (PLFLT)(val2);
15104  if (arg1) (arg1)->wX = arg2;
15105  _outv = octave_value();
15106  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15107 fail:
15108  return _out;
15109 }
15110 
15111 
15112 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
15113  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15114  void *argp1 = 0 ;
15115  int res1 = 0 ;
15116  octave_value_list _out;
15117  octave_value_list *_outp=&_out;
15118  octave_value _outv;
15119  PLFLT result;
15120 
15121  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
15122  SWIG_fail;
15123  }
15124  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15125  if (!SWIG_IsOK(res1)) {
15126  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15127  }
15128  arg1 = (PLGraphicsIn *)(argp1);
15129  result = (PLFLT) ((arg1)->wX);
15130  _outv = SWIG_From_double((double)(result));
15131  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15132 fail:
15133  return _out;
15134 }
15135 
15136 
15137 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
15138  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15139  PLFLT arg2 ;
15140  void *argp1 = 0 ;
15141  int res1 = 0 ;
15142  double val2 ;
15143  int ecode2 = 0 ;
15144  octave_value_list _out;
15145  octave_value_list *_outp=&_out;
15146  octave_value _outv;
15147 
15148  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
15149  SWIG_fail;
15150  }
15151  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15152  if (!SWIG_IsOK(res1)) {
15153  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15154  }
15155  arg1 = (PLGraphicsIn *)(argp1);
15156  ecode2 = SWIG_AsVal_double(args(1), &val2);
15157  if (!SWIG_IsOK(ecode2)) {
15158  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
15159  }
15160  arg2 = (PLFLT)(val2);
15161  if (arg1) (arg1)->wY = arg2;
15162  _outv = octave_value();
15163  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15164 fail:
15165  return _out;
15166 }
15167 
15168 
15169 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
15170  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15171  void *argp1 = 0 ;
15172  int res1 = 0 ;
15173  octave_value_list _out;
15174  octave_value_list *_outp=&_out;
15175  octave_value _outv;
15176  PLFLT result;
15177 
15178  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
15179  SWIG_fail;
15180  }
15181  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15182  if (!SWIG_IsOK(res1)) {
15183  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15184  }
15185  arg1 = (PLGraphicsIn *)(argp1);
15186  result = (PLFLT) ((arg1)->wY);
15187  _outv = SWIG_From_double((double)(result));
15188  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15189 fail:
15190  return _out;
15191 }
15192 
15193 
15194 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
15195  octave_value_list _out;
15196  octave_value_list *_outp=&_out;
15197  octave_value _outv;
15198  PLGraphicsIn *result = 0 ;
15199 
15200  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
15201  SWIG_fail;
15202  }
15203  result = (PLGraphicsIn *)new PLGraphicsIn();
15205  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15206 fail:
15207  return _out;
15208 }
15209 
15210 
15211 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
15212  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15213  void *argp1 = 0 ;
15214  int res1 = 0 ;
15215  octave_value_list _out;
15216  octave_value_list *_outp=&_out;
15217  octave_value _outv;
15218 
15219  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
15220  SWIG_fail;
15221  }
15222  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
15223  if (!SWIG_IsOK(res1)) {
15224  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15225  }
15226  arg1 = (PLGraphicsIn *)(argp1);
15227  delete arg1;
15228  _outv = octave_value();
15229  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15230 fail:
15231  return _out;
15232 }
15233 
15234 
15248 {0,0,0,0}
15249 };
15250 static const char *swig_PLGraphicsIn_base_names[] = {0};
15253 
15254 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
15255  PLINT arg1 ;
15256  PLINT arg2 ;
15257  int val1 ;
15258  int ecode1 = 0 ;
15259  int val2 ;
15260  int ecode2 = 0 ;
15261  octave_value_list _out;
15262  octave_value_list *_outp=&_out;
15263  octave_value _outv;
15264 
15265  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
15266  SWIG_fail;
15267  }
15268  ecode1 = SWIG_AsVal_int(args(0), &val1);
15269  if (!SWIG_IsOK(ecode1)) {
15270  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
15271  }
15272  arg1 = (PLINT)(val1);
15273  ecode2 = SWIG_AsVal_int(args(1), &val2);
15274  if (!SWIG_IsOK(ecode2)) {
15275  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
15276  }
15277  arg2 = (PLINT)(val2);
15278  pl_setcontlabelformat(arg1,arg2);
15279  _outv = octave_value();
15280  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15281 fail:
15282  return _out;
15283 }
15284 
15285 
15286 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
15287  PLFLT arg1 ;
15288  PLFLT arg2 ;
15289  PLFLT arg3 ;
15290  PLINT arg4 ;
15291  double val1 ;
15292  int ecode1 = 0 ;
15293  double val2 ;
15294  int ecode2 = 0 ;
15295  double val3 ;
15296  int ecode3 = 0 ;
15297  int val4 ;
15298  int ecode4 = 0 ;
15299  octave_value_list _out;
15300  octave_value_list *_outp=&_out;
15301  octave_value _outv;
15302 
15303  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
15304  SWIG_fail;
15305  }
15306  ecode1 = SWIG_AsVal_double(args(0), &val1);
15307  if (!SWIG_IsOK(ecode1)) {
15308  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
15309  }
15310  arg1 = (PLFLT)(val1);
15311  ecode2 = SWIG_AsVal_double(args(1), &val2);
15312  if (!SWIG_IsOK(ecode2)) {
15313  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
15314  }
15315  arg2 = (PLFLT)(val2);
15316  ecode3 = SWIG_AsVal_double(args(2), &val3);
15317  if (!SWIG_IsOK(ecode3)) {
15318  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
15319  }
15320  arg3 = (PLFLT)(val3);
15321  ecode4 = SWIG_AsVal_int(args(3), &val4);
15322  if (!SWIG_IsOK(ecode4)) {
15323  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
15324  }
15325  arg4 = (PLINT)(val4);
15326  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
15327  _outv = octave_value();
15328  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15329 fail:
15330  return _out;
15331 }
15332 
15333 
15334 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
15335  PLINT arg1 ;
15336  int val1 ;
15337  int ecode1 = 0 ;
15338  octave_value_list _out;
15339  octave_value_list *_outp=&_out;
15340  octave_value _outv;
15341 
15342  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
15343  SWIG_fail;
15344  }
15345  ecode1 = SWIG_AsVal_int(args(0), &val1);
15346  if (!SWIG_IsOK(ecode1)) {
15347  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
15348  }
15349  arg1 = (PLINT)(val1);
15350  pladv(arg1);
15351  _outv = octave_value();
15352  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15353 fail:
15354  return _out;
15355 }
15356 
15357 
15358 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
15359  PLFLT arg1 ;
15360  PLFLT arg2 ;
15361  PLFLT arg3 ;
15362  PLFLT arg4 ;
15363  PLFLT arg5 ;
15364  PLFLT arg6 ;
15365  PLFLT arg7 ;
15366  PLBOOL arg8 ;
15367  double val1 ;
15368  int ecode1 = 0 ;
15369  double val2 ;
15370  int ecode2 = 0 ;
15371  double val3 ;
15372  int ecode3 = 0 ;
15373  double val4 ;
15374  int ecode4 = 0 ;
15375  double val5 ;
15376  int ecode5 = 0 ;
15377  double val6 ;
15378  int ecode6 = 0 ;
15379  double val7 ;
15380  int ecode7 = 0 ;
15381  int val8 ;
15382  int ecode8 = 0 ;
15383  octave_value_list _out;
15384  octave_value_list *_outp=&_out;
15385  octave_value _outv;
15386 
15387  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
15388  SWIG_fail;
15389  }
15390  ecode1 = SWIG_AsVal_double(args(0), &val1);
15391  if (!SWIG_IsOK(ecode1)) {
15392  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
15393  }
15394  arg1 = (PLFLT)(val1);
15395  ecode2 = SWIG_AsVal_double(args(1), &val2);
15396  if (!SWIG_IsOK(ecode2)) {
15397  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
15398  }
15399  arg2 = (PLFLT)(val2);
15400  ecode3 = SWIG_AsVal_double(args(2), &val3);
15401  if (!SWIG_IsOK(ecode3)) {
15402  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
15403  }
15404  arg3 = (PLFLT)(val3);
15405  ecode4 = SWIG_AsVal_double(args(3), &val4);
15406  if (!SWIG_IsOK(ecode4)) {
15407  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
15408  }
15409  arg4 = (PLFLT)(val4);
15410  ecode5 = SWIG_AsVal_double(args(4), &val5);
15411  if (!SWIG_IsOK(ecode5)) {
15412  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
15413  }
15414  arg5 = (PLFLT)(val5);
15415  ecode6 = SWIG_AsVal_double(args(5), &val6);
15416  if (!SWIG_IsOK(ecode6)) {
15417  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
15418  }
15419  arg6 = (PLFLT)(val6);
15420  ecode7 = SWIG_AsVal_double(args(6), &val7);
15421  if (!SWIG_IsOK(ecode7)) {
15422  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
15423  }
15424  arg7 = (PLFLT)(val7);
15425  ecode8 = SWIG_AsVal_int(args(7), &val8);
15426  if (!SWIG_IsOK(ecode8)) {
15427  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
15428  }
15429  arg8 = (PLBOOL)(val8);
15430  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15431  _outv = octave_value();
15432  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15433 fail:
15434  return _out;
15435 }
15436 
15437 
15438 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
15439  PLFLT arg1 ;
15440  PLFLT arg2 ;
15441  char *arg3 = (char *) 0 ;
15442  PLFLT arg4 ;
15443  PLINT arg5 ;
15444  char *arg6 = (char *) 0 ;
15445  PLFLT arg7 ;
15446  PLINT arg8 ;
15447  double val1 ;
15448  int ecode1 = 0 ;
15449  double val2 ;
15450  int ecode2 = 0 ;
15451  int res3 ;
15452  char *buf3 = 0 ;
15453  int alloc3 = 0 ;
15454  double val4 ;
15455  int ecode4 = 0 ;
15456  int val5 ;
15457  int ecode5 = 0 ;
15458  int res6 ;
15459  char *buf6 = 0 ;
15460  int alloc6 = 0 ;
15461  double val7 ;
15462  int ecode7 = 0 ;
15463  int val8 ;
15464  int ecode8 = 0 ;
15465  octave_value_list _out;
15466  octave_value_list *_outp=&_out;
15467  octave_value _outv;
15468 
15469  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
15470  SWIG_fail;
15471  }
15472  ecode1 = SWIG_AsVal_double(args(0), &val1);
15473  if (!SWIG_IsOK(ecode1)) {
15474  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
15475  }
15476  arg1 = (PLFLT)(val1);
15477  ecode2 = SWIG_AsVal_double(args(1), &val2);
15478  if (!SWIG_IsOK(ecode2)) {
15479  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
15480  }
15481  arg2 = (PLFLT)(val2);
15482  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
15483  if (!SWIG_IsOK(res3)) {
15484  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
15485  }
15486  arg3 = (char *)(buf3);
15487  ecode4 = SWIG_AsVal_double(args(3), &val4);
15488  if (!SWIG_IsOK(ecode4)) {
15489  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
15490  }
15491  arg4 = (PLFLT)(val4);
15492  ecode5 = SWIG_AsVal_int(args(4), &val5);
15493  if (!SWIG_IsOK(ecode5)) {
15494  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
15495  }
15496  arg5 = (PLINT)(val5);
15497  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
15498  if (!SWIG_IsOK(res6)) {
15499  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
15500  }
15501  arg6 = (char *)(buf6);
15502  ecode7 = SWIG_AsVal_double(args(6), &val7);
15503  if (!SWIG_IsOK(ecode7)) {
15504  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
15505  }
15506  arg7 = (PLFLT)(val7);
15507  ecode8 = SWIG_AsVal_int(args(7), &val8);
15508  if (!SWIG_IsOK(ecode8)) {
15509  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
15510  }
15511  arg8 = (PLINT)(val8);
15512  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
15513  _outv = octave_value();
15514  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15515  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15516  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
15517 fail:
15518  return _out;
15519 }
15520 
15521 
15522 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
15523  PLINT arg1 ;
15524  PLFLT *arg2 = (PLFLT *) 0 ;
15525  PLFLT *arg3 = (PLFLT *) 0 ;
15526  PLINT arg4 ;
15527  Matrix temp1 ;
15528  Matrix temp3 ;
15529  int val4 ;
15530  int ecode4 = 0 ;
15531  octave_value_list _out;
15532  octave_value_list *_outp=&_out;
15533  octave_value _outv;
15534 
15535  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
15536  SWIG_fail;
15537  }
15538  {
15539  if ( _n_dims( args(0) ) > 1 )
15540  {
15541  error( "argument must be a scalar or vector" ); SWIG_fail;
15542  }
15543  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
15544  temp1 = args(0).matrix_value();
15545  arg2 = &temp1( 0, 0 );
15546  }
15547  {
15548  if ( _n_dims( args(1) ) > 1 )
15549  {
15550  error( "argument must be a scalar or vector" ); SWIG_fail;
15551  }
15552  if ( _dim( args(1), 0 ) != Alen )
15553  {
15554  error( "argument vectors must be same length" ); SWIG_fail;
15555  }
15556  temp3 = args(1).matrix_value();
15557  arg3 = &temp3( 0, 0 );
15558  }
15559  ecode4 = SWIG_AsVal_int(args(2), &val4);
15560  if (!SWIG_IsOK(ecode4)) {
15561  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
15562  }
15563  arg4 = (PLINT)(val4);
15564  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
15565  _outv = octave_value();
15566  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15567  {
15568 
15569  }
15570  {
15571 
15572  }
15573 fail:
15574  return _out;
15575 }
15576 
15577 
15578 SWIG_DEFUN( plbtime, _wrap_plbtime, _wrap_plbtime_texinfo ) {
15579  PLINT *arg1 = (PLINT *) 0 ;
15580  PLINT *arg2 = (PLINT *) 0 ;
15581  PLINT *arg3 = (PLINT *) 0 ;
15582  PLINT *arg4 = (PLINT *) 0 ;
15583  PLINT *arg5 = (PLINT *) 0 ;
15584  PLFLT *arg6 = (PLFLT *) 0 ;
15585  PLFLT arg7 ;
15586  PLINT temp1 ;
15587  int res1 = SWIG_TMPOBJ ;
15588  PLINT temp2 ;
15589  int res2 = SWIG_TMPOBJ ;
15590  PLINT temp3 ;
15591  int res3 = SWIG_TMPOBJ ;
15592  PLINT temp4 ;
15593  int res4 = SWIG_TMPOBJ ;
15594  PLINT temp5 ;
15595  int res5 = SWIG_TMPOBJ ;
15596  PLFLT temp6 ;
15597  int res6 = SWIG_TMPOBJ ;
15598  double val7 ;
15599  int ecode7 = 0 ;
15600  octave_value_list _out;
15601  octave_value_list *_outp=&_out;
15602  octave_value _outv;
15603 
15604  arg1 = &temp1;
15605  arg2 = &temp2;
15606  arg3 = &temp3;
15607  arg4 = &temp4;
15608  arg5 = &temp5;
15609  arg6 = &temp6;
15610  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
15611  SWIG_fail;
15612  }
15613  ecode7 = SWIG_AsVal_double(args(0), &val7);
15614  if (!SWIG_IsOK(ecode7)) {
15615  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
15616  }
15617  arg7 = (PLFLT)(val7);
15618  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
15619  _outv = octave_value();
15620  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15621  if (SWIG_IsTmpObj(res1)) {
15622  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15623  } else {
15624  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15625  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15626  }
15627  if (SWIG_IsTmpObj(res2)) {
15628  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15629  } else {
15630  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15631  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15632  }
15633  if (SWIG_IsTmpObj(res3)) {
15634  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15635  } else {
15636  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15637  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15638  }
15639  if (SWIG_IsTmpObj(res4)) {
15640  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15641  } else {
15642  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15643  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15644  }
15645  if (SWIG_IsTmpObj(res5)) {
15646  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15647  } else {
15648  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15649  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15650  }
15651  if (SWIG_IsTmpObj(res6)) {
15652  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
15653  } else {
15654  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15655  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
15656  }
15657 fail:
15658  return _out;
15659 }
15660 
15661 
15662 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
15663  octave_value_list _out;
15664  octave_value_list *_outp=&_out;
15665  octave_value _outv;
15666 
15667  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
15668  SWIG_fail;
15669  }
15670  plbop();
15671  _outv = octave_value();
15672  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15673 fail:
15674  return _out;
15675 }
15676 
15677 
15678 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
15679  char *arg1 = (char *) 0 ;
15680  PLFLT arg2 ;
15681  PLINT arg3 ;
15682  char *arg4 = (char *) 0 ;
15683  PLFLT arg5 ;
15684  PLINT arg6 ;
15685  int res1 ;
15686  char *buf1 = 0 ;
15687  int alloc1 = 0 ;
15688  double val2 ;
15689  int ecode2 = 0 ;
15690  int val3 ;
15691  int ecode3 = 0 ;
15692  int res4 ;
15693  char *buf4 = 0 ;
15694  int alloc4 = 0 ;
15695  double val5 ;
15696  int ecode5 = 0 ;
15697  int val6 ;
15698  int ecode6 = 0 ;
15699  octave_value_list _out;
15700  octave_value_list *_outp=&_out;
15701  octave_value _outv;
15702 
15703  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
15704  SWIG_fail;
15705  }
15706  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15707  if (!SWIG_IsOK(res1)) {
15708  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
15709  }
15710  arg1 = (char *)(buf1);
15711  ecode2 = SWIG_AsVal_double(args(1), &val2);
15712  if (!SWIG_IsOK(ecode2)) {
15713  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
15714  }
15715  arg2 = (PLFLT)(val2);
15716  ecode3 = SWIG_AsVal_int(args(2), &val3);
15717  if (!SWIG_IsOK(ecode3)) {
15718  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
15719  }
15720  arg3 = (PLINT)(val3);
15721  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
15722  if (!SWIG_IsOK(res4)) {
15723  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
15724  }
15725  arg4 = (char *)(buf4);
15726  ecode5 = SWIG_AsVal_double(args(4), &val5);
15727  if (!SWIG_IsOK(ecode5)) {
15728  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
15729  }
15730  arg5 = (PLFLT)(val5);
15731  ecode6 = SWIG_AsVal_int(args(5), &val6);
15732  if (!SWIG_IsOK(ecode6)) {
15733  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
15734  }
15735  arg6 = (PLINT)(val6);
15736  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
15737  _outv = octave_value();
15738  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15739  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15740  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
15741 fail:
15742  return _out;
15743 }
15744 
15745 
15746 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
15747  char *arg1 = (char *) 0 ;
15748  char *arg2 = (char *) 0 ;
15749  PLFLT arg3 ;
15750  PLINT arg4 ;
15751  char *arg5 = (char *) 0 ;
15752  char *arg6 = (char *) 0 ;
15753  PLFLT arg7 ;
15754  PLINT arg8 ;
15755  char *arg9 = (char *) 0 ;
15756  char *arg10 = (char *) 0 ;
15757  PLFLT arg11 ;
15758  PLINT arg12 ;
15759  int res1 ;
15760  char *buf1 = 0 ;
15761  int alloc1 = 0 ;
15762  int res2 ;
15763  char *buf2 = 0 ;
15764  int alloc2 = 0 ;
15765  double val3 ;
15766  int ecode3 = 0 ;
15767  int val4 ;
15768  int ecode4 = 0 ;
15769  int res5 ;
15770  char *buf5 = 0 ;
15771  int alloc5 = 0 ;
15772  int res6 ;
15773  char *buf6 = 0 ;
15774  int alloc6 = 0 ;
15775  double val7 ;
15776  int ecode7 = 0 ;
15777  int val8 ;
15778  int ecode8 = 0 ;
15779  int res9 ;
15780  char *buf9 = 0 ;
15781  int alloc9 = 0 ;
15782  int res10 ;
15783  char *buf10 = 0 ;
15784  int alloc10 = 0 ;
15785  double val11 ;
15786  int ecode11 = 0 ;
15787  int val12 ;
15788  int ecode12 = 0 ;
15789  octave_value_list _out;
15790  octave_value_list *_outp=&_out;
15791  octave_value _outv;
15792 
15793  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
15794  SWIG_fail;
15795  }
15796  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15797  if (!SWIG_IsOK(res1)) {
15798  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
15799  }
15800  arg1 = (char *)(buf1);
15801  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
15802  if (!SWIG_IsOK(res2)) {
15803  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
15804  }
15805  arg2 = (char *)(buf2);
15806  ecode3 = SWIG_AsVal_double(args(2), &val3);
15807  if (!SWIG_IsOK(ecode3)) {
15808  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
15809  }
15810  arg3 = (PLFLT)(val3);
15811  ecode4 = SWIG_AsVal_int(args(3), &val4);
15812  if (!SWIG_IsOK(ecode4)) {
15813  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
15814  }
15815  arg4 = (PLINT)(val4);
15816  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
15817  if (!SWIG_IsOK(res5)) {
15818  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
15819  }
15820  arg5 = (char *)(buf5);
15821  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
15822  if (!SWIG_IsOK(res6)) {
15823  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
15824  }
15825  arg6 = (char *)(buf6);
15826  ecode7 = SWIG_AsVal_double(args(6), &val7);
15827  if (!SWIG_IsOK(ecode7)) {
15828  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
15829  }
15830  arg7 = (PLFLT)(val7);
15831  ecode8 = SWIG_AsVal_int(args(7), &val8);
15832  if (!SWIG_IsOK(ecode8)) {
15833  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
15834  }
15835  arg8 = (PLINT)(val8);
15836  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
15837  if (!SWIG_IsOK(res9)) {
15838  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
15839  }
15840  arg9 = (char *)(buf9);
15841  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
15842  if (!SWIG_IsOK(res10)) {
15843  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
15844  }
15845  arg10 = (char *)(buf10);
15846  ecode11 = SWIG_AsVal_double(args(10), &val11);
15847  if (!SWIG_IsOK(ecode11)) {
15848  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
15849  }
15850  arg11 = (PLFLT)(val11);
15851  ecode12 = SWIG_AsVal_int(args(11), &val12);
15852  if (!SWIG_IsOK(ecode12)) {
15853  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
15854  }
15855  arg12 = (PLINT)(val12);
15856  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);
15857  _outv = octave_value();
15858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15859  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15860  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15861  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
15862  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
15863  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
15864  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
15865 fail:
15866  return _out;
15867 }
15868 
15869 
15870 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
15871  PLFLT arg1 ;
15872  PLFLT arg2 ;
15873  PLFLT *arg3 = (PLFLT *) 0 ;
15874  PLFLT *arg4 = (PLFLT *) 0 ;
15875  PLINT *arg5 = (PLINT *) 0 ;
15876  double val1 ;
15877  int ecode1 = 0 ;
15878  double val2 ;
15879  int ecode2 = 0 ;
15880  PLFLT temp3 ;
15881  int res3 = SWIG_TMPOBJ ;
15882  PLFLT temp4 ;
15883  int res4 = SWIG_TMPOBJ ;
15884  PLINT temp5 ;
15885  int res5 = SWIG_TMPOBJ ;
15886  octave_value_list _out;
15887  octave_value_list *_outp=&_out;
15888  octave_value _outv;
15889 
15890  arg3 = &temp3;
15891  arg4 = &temp4;
15892  arg5 = &temp5;
15893  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
15894  SWIG_fail;
15895  }
15896  ecode1 = SWIG_AsVal_double(args(0), &val1);
15897  if (!SWIG_IsOK(ecode1)) {
15898  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
15899  }
15900  arg1 = (PLFLT)(val1);
15901  ecode2 = SWIG_AsVal_double(args(1), &val2);
15902  if (!SWIG_IsOK(ecode2)) {
15903  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
15904  }
15905  arg2 = (PLFLT)(val2);
15906  plcalc_world(arg1,arg2,arg3,arg4,arg5);
15907  _outv = octave_value();
15908  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15909  if (SWIG_IsTmpObj(res3)) {
15910  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15911  } else {
15912  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15913  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15914  }
15915  if (SWIG_IsTmpObj(res4)) {
15916  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15917  } else {
15918  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15919  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15920  }
15921  if (SWIG_IsTmpObj(res5)) {
15922  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15923  } else {
15924  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15925  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15926  }
15927 fail:
15928  return _out;
15929 }
15930 
15931 
15932 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
15933  octave_value_list _out;
15934  octave_value_list *_outp=&_out;
15935  octave_value _outv;
15936 
15937  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
15938  SWIG_fail;
15939  }
15940  plclear();
15941  _outv = octave_value();
15942  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15943 fail:
15944  return _out;
15945 }
15946 
15947 
15948 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
15949  PLINT arg1 ;
15950  int val1 ;
15951  int ecode1 = 0 ;
15952  octave_value_list _out;
15953  octave_value_list *_outp=&_out;
15954  octave_value _outv;
15955 
15956  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
15957  SWIG_fail;
15958  }
15959  ecode1 = SWIG_AsVal_int(args(0), &val1);
15960  if (!SWIG_IsOK(ecode1)) {
15961  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
15962  }
15963  arg1 = (PLINT)(val1);
15964  plcol0(arg1);
15965  _outv = octave_value();
15966  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15967 fail:
15968  return _out;
15969 }
15970 
15971 
15972 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
15973  PLFLT arg1 ;
15974  double val1 ;
15975  int ecode1 = 0 ;
15976  octave_value_list _out;
15977  octave_value_list *_outp=&_out;
15978  octave_value _outv;
15979 
15980  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
15981  SWIG_fail;
15982  }
15983  ecode1 = SWIG_AsVal_double(args(0), &val1);
15984  if (!SWIG_IsOK(ecode1)) {
15985  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
15986  }
15987  arg1 = (PLFLT)(val1);
15988  plcol1(arg1);
15989  _outv = octave_value();
15990  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15991 fail:
15992  return _out;
15993 }
15994 
15995 
15996 SWIG_DEFUN( plconfigtime, _wrap_plconfigtime, _wrap_plconfigtime_texinfo ) {
15997  PLFLT arg1 ;
15998  PLFLT arg2 ;
15999  PLFLT arg3 ;
16000  PLINT arg4 ;
16001  PLBOOL arg5 ;
16002  PLINT arg6 ;
16003  PLINT arg7 ;
16004  PLINT arg8 ;
16005  PLINT arg9 ;
16006  PLINT arg10 ;
16007  PLFLT arg11 ;
16008  double val1 ;
16009  int ecode1 = 0 ;
16010  double val2 ;
16011  int ecode2 = 0 ;
16012  double val3 ;
16013  int ecode3 = 0 ;
16014  int val4 ;
16015  int ecode4 = 0 ;
16016  int val5 ;
16017  int ecode5 = 0 ;
16018  int val6 ;
16019  int ecode6 = 0 ;
16020  int val7 ;
16021  int ecode7 = 0 ;
16022  int val8 ;
16023  int ecode8 = 0 ;
16024  int val9 ;
16025  int ecode9 = 0 ;
16026  int val10 ;
16027  int ecode10 = 0 ;
16028  double val11 ;
16029  int ecode11 = 0 ;
16030  octave_value_list _out;
16031  octave_value_list *_outp=&_out;
16032  octave_value _outv;
16033 
16034  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
16035  SWIG_fail;
16036  }
16037  ecode1 = SWIG_AsVal_double(args(0), &val1);
16038  if (!SWIG_IsOK(ecode1)) {
16039  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
16040  }
16041  arg1 = (PLFLT)(val1);
16042  ecode2 = SWIG_AsVal_double(args(1), &val2);
16043  if (!SWIG_IsOK(ecode2)) {
16044  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
16045  }
16046  arg2 = (PLFLT)(val2);
16047  ecode3 = SWIG_AsVal_double(args(2), &val3);
16048  if (!SWIG_IsOK(ecode3)) {
16049  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
16050  }
16051  arg3 = (PLFLT)(val3);
16052  ecode4 = SWIG_AsVal_int(args(3), &val4);
16053  if (!SWIG_IsOK(ecode4)) {
16054  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
16055  }
16056  arg4 = (PLINT)(val4);
16057  ecode5 = SWIG_AsVal_int(args(4), &val5);
16058  if (!SWIG_IsOK(ecode5)) {
16059  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
16060  }
16061  arg5 = (PLBOOL)(val5);
16062  ecode6 = SWIG_AsVal_int(args(5), &val6);
16063  if (!SWIG_IsOK(ecode6)) {
16064  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
16065  }
16066  arg6 = (PLINT)(val6);
16067  ecode7 = SWIG_AsVal_int(args(6), &val7);
16068  if (!SWIG_IsOK(ecode7)) {
16069  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
16070  }
16071  arg7 = (PLINT)(val7);
16072  ecode8 = SWIG_AsVal_int(args(7), &val8);
16073  if (!SWIG_IsOK(ecode8)) {
16074  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
16075  }
16076  arg8 = (PLINT)(val8);
16077  ecode9 = SWIG_AsVal_int(args(8), &val9);
16078  if (!SWIG_IsOK(ecode9)) {
16079  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
16080  }
16081  arg9 = (PLINT)(val9);
16082  ecode10 = SWIG_AsVal_int(args(9), &val10);
16083  if (!SWIG_IsOK(ecode10)) {
16084  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
16085  }
16086  arg10 = (PLINT)(val10);
16087  ecode11 = SWIG_AsVal_double(args(10), &val11);
16088  if (!SWIG_IsOK(ecode11)) {
16089  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
16090  }
16091  arg11 = (PLFLT)(val11);
16092  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16093  _outv = octave_value();
16094  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16095 fail:
16096  return _out;
16097 }
16098 
16099 
16100 SWIG_DEFUN( plctime, _wrap_plctime, _wrap_plctime_texinfo ) {
16101  PLINT arg1 ;
16102  PLINT arg2 ;
16103  PLINT arg3 ;
16104  PLINT arg4 ;
16105  PLINT arg5 ;
16106  PLFLT arg6 ;
16107  PLFLT *arg7 = (PLFLT *) 0 ;
16108  int val1 ;
16109  int ecode1 = 0 ;
16110  int val2 ;
16111  int ecode2 = 0 ;
16112  int val3 ;
16113  int ecode3 = 0 ;
16114  int val4 ;
16115  int ecode4 = 0 ;
16116  int val5 ;
16117  int ecode5 = 0 ;
16118  double val6 ;
16119  int ecode6 = 0 ;
16120  PLFLT temp7 ;
16121  int res7 = SWIG_TMPOBJ ;
16122  octave_value_list _out;
16123  octave_value_list *_outp=&_out;
16124  octave_value _outv;
16125 
16126  arg7 = &temp7;
16127  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
16128  SWIG_fail;
16129  }
16130  ecode1 = SWIG_AsVal_int(args(0), &val1);
16131  if (!SWIG_IsOK(ecode1)) {
16132  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
16133  }
16134  arg1 = (PLINT)(val1);
16135  ecode2 = SWIG_AsVal_int(args(1), &val2);
16136  if (!SWIG_IsOK(ecode2)) {
16137  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
16138  }
16139  arg2 = (PLINT)(val2);
16140  ecode3 = SWIG_AsVal_int(args(2), &val3);
16141  if (!SWIG_IsOK(ecode3)) {
16142  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
16143  }
16144  arg3 = (PLINT)(val3);
16145  ecode4 = SWIG_AsVal_int(args(3), &val4);
16146  if (!SWIG_IsOK(ecode4)) {
16147  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
16148  }
16149  arg4 = (PLINT)(val4);
16150  ecode5 = SWIG_AsVal_int(args(4), &val5);
16151  if (!SWIG_IsOK(ecode5)) {
16152  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
16153  }
16154  arg5 = (PLINT)(val5);
16155  ecode6 = SWIG_AsVal_double(args(5), &val6);
16156  if (!SWIG_IsOK(ecode6)) {
16157  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
16158  }
16159  arg6 = (PLFLT)(val6);
16160  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16161  _outv = octave_value();
16162  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16163  if (SWIG_IsTmpObj(res7)) {
16164  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
16165  } else {
16166  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16167  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
16168  }
16169 fail:
16170  return _out;
16171 }
16172 
16173 
16174 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
16175  PLINT arg1 ;
16176  PLBOOL arg2 ;
16177  int val1 ;
16178  int ecode1 = 0 ;
16179  int val2 ;
16180  int ecode2 = 0 ;
16181  octave_value_list _out;
16182  octave_value_list *_outp=&_out;
16183  octave_value _outv;
16184 
16185  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
16186  SWIG_fail;
16187  }
16188  ecode1 = SWIG_AsVal_int(args(0), &val1);
16189  if (!SWIG_IsOK(ecode1)) {
16190  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
16191  }
16192  arg1 = (PLINT)(val1);
16193  ecode2 = SWIG_AsVal_int(args(1), &val2);
16194  if (!SWIG_IsOK(ecode2)) {
16195  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
16196  }
16197  arg2 = (PLBOOL)(val2);
16198  plcpstrm(arg1,arg2);
16199  _outv = octave_value();
16200  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16201 fail:
16202  return _out;
16203 }
16204 
16205 
16206 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
16207  octave_value_list _out;
16208  octave_value_list *_outp=&_out;
16209  octave_value _outv;
16210 
16211  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
16212  SWIG_fail;
16213  }
16214  plend();
16215  _outv = octave_value();
16216  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16217 fail:
16218  return _out;
16219 }
16220 
16221 
16222 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
16223  octave_value_list _out;
16224  octave_value_list *_outp=&_out;
16225  octave_value _outv;
16226 
16227  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
16228  SWIG_fail;
16229  }
16230  plend1();
16231  _outv = octave_value();
16232  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16233 fail:
16234  return _out;
16235 }
16236 
16237 
16238 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
16239  PLFLT arg1 ;
16240  PLFLT arg2 ;
16241  PLFLT arg3 ;
16242  PLFLT arg4 ;
16243  PLINT arg5 ;
16244  PLINT arg6 ;
16245  double val1 ;
16246  int ecode1 = 0 ;
16247  double val2 ;
16248  int ecode2 = 0 ;
16249  double val3 ;
16250  int ecode3 = 0 ;
16251  double val4 ;
16252  int ecode4 = 0 ;
16253  int val5 ;
16254  int ecode5 = 0 ;
16255  int val6 ;
16256  int ecode6 = 0 ;
16257  octave_value_list _out;
16258  octave_value_list *_outp=&_out;
16259  octave_value _outv;
16260 
16261  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
16262  SWIG_fail;
16263  }
16264  ecode1 = SWIG_AsVal_double(args(0), &val1);
16265  if (!SWIG_IsOK(ecode1)) {
16266  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
16267  }
16268  arg1 = (PLFLT)(val1);
16269  ecode2 = SWIG_AsVal_double(args(1), &val2);
16270  if (!SWIG_IsOK(ecode2)) {
16271  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
16272  }
16273  arg2 = (PLFLT)(val2);
16274  ecode3 = SWIG_AsVal_double(args(2), &val3);
16275  if (!SWIG_IsOK(ecode3)) {
16276  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
16277  }
16278  arg3 = (PLFLT)(val3);
16279  ecode4 = SWIG_AsVal_double(args(3), &val4);
16280  if (!SWIG_IsOK(ecode4)) {
16281  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
16282  }
16283  arg4 = (PLFLT)(val4);
16284  ecode5 = SWIG_AsVal_int(args(4), &val5);
16285  if (!SWIG_IsOK(ecode5)) {
16286  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
16287  }
16288  arg5 = (PLINT)(val5);
16289  ecode6 = SWIG_AsVal_int(args(5), &val6);
16290  if (!SWIG_IsOK(ecode6)) {
16291  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
16292  }
16293  arg6 = (PLINT)(val6);
16294  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16295  _outv = octave_value();
16296  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16297 fail:
16298  return _out;
16299 }
16300 
16301 
16302 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
16303  PLFLT arg1 ;
16304  PLFLT arg2 ;
16305  PLFLT arg3 ;
16306  PLFLT arg4 ;
16307  PLINT arg5 ;
16308  PLINT arg6 ;
16309  double val1 ;
16310  int ecode1 = 0 ;
16311  double val2 ;
16312  int ecode2 = 0 ;
16313  double val3 ;
16314  int ecode3 = 0 ;
16315  double val4 ;
16316  int ecode4 = 0 ;
16317  int val5 ;
16318  int ecode5 = 0 ;
16319  int val6 ;
16320  int ecode6 = 0 ;
16321  octave_value_list _out;
16322  octave_value_list *_outp=&_out;
16323  octave_value _outv;
16324 
16325  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
16326  SWIG_fail;
16327  }
16328  ecode1 = SWIG_AsVal_double(args(0), &val1);
16329  if (!SWIG_IsOK(ecode1)) {
16330  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
16331  }
16332  arg1 = (PLFLT)(val1);
16333  ecode2 = SWIG_AsVal_double(args(1), &val2);
16334  if (!SWIG_IsOK(ecode2)) {
16335  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
16336  }
16337  arg2 = (PLFLT)(val2);
16338  ecode3 = SWIG_AsVal_double(args(2), &val3);
16339  if (!SWIG_IsOK(ecode3)) {
16340  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
16341  }
16342  arg3 = (PLFLT)(val3);
16343  ecode4 = SWIG_AsVal_double(args(3), &val4);
16344  if (!SWIG_IsOK(ecode4)) {
16345  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
16346  }
16347  arg4 = (PLFLT)(val4);
16348  ecode5 = SWIG_AsVal_int(args(4), &val5);
16349  if (!SWIG_IsOK(ecode5)) {
16350  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
16351  }
16352  arg5 = (PLINT)(val5);
16353  ecode6 = SWIG_AsVal_int(args(5), &val6);
16354  if (!SWIG_IsOK(ecode6)) {
16355  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
16356  }
16357  arg6 = (PLINT)(val6);
16358  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
16359  _outv = octave_value();
16360  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16361 fail:
16362  return _out;
16363 }
16364 
16365 
16366 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
16367  octave_value_list _out;
16368  octave_value_list *_outp=&_out;
16369  octave_value _outv;
16370 
16371  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
16372  SWIG_fail;
16373  }
16374  pleop();
16375  _outv = octave_value();
16376  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16377 fail:
16378  return _out;
16379 }
16380 
16381 
16382 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
16383  PLINT arg1 ;
16384  PLFLT *arg2 = (PLFLT *) 0 ;
16385  PLFLT *arg3 = (PLFLT *) 0 ;
16386  PLFLT *arg4 = (PLFLT *) 0 ;
16387  Matrix temp1 ;
16388  Matrix temp3 ;
16389  Matrix temp4 ;
16390  octave_value_list _out;
16391  octave_value_list *_outp=&_out;
16392  octave_value _outv;
16393 
16394  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
16395  SWIG_fail;
16396  }
16397  {
16398  if ( _n_dims( args(0) ) > 1 )
16399  {
16400  error( "argument must be a scalar or vector" ); SWIG_fail;
16401  }
16402  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16403  temp1 = args(0).matrix_value();
16404  arg2 = &temp1( 0, 0 );
16405  }
16406  {
16407  if ( _n_dims( args(1) ) > 1 )
16408  {
16409  error( "argument must be a scalar or vector" ); SWIG_fail;
16410  }
16411  if ( _dim( args(1), 0 ) != Alen )
16412  {
16413  error( "argument vectors must be same length" ); SWIG_fail;
16414  }
16415  temp3 = args(1).matrix_value();
16416  arg3 = &temp3( 0, 0 );
16417  }
16418  {
16419  if ( _n_dims( args(2) ) > 1 )
16420  {
16421  error( "argument must be a scalar or vector" ); SWIG_fail;
16422  }
16423  if ( _dim( args(2), 0 ) != Alen )
16424  {
16425  error( "argument vectors must be same length" ); SWIG_fail;
16426  }
16427  temp4 = args(2).matrix_value();
16428  arg4 = &temp4( 0, 0 );
16429  }
16430  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16431  _outv = octave_value();
16432  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16433  {
16434 
16435  }
16436  {
16437 
16438  }
16439  {
16440 
16441  }
16442 fail:
16443  return _out;
16444 }
16445 
16446 
16447 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
16448  PLINT arg1 ;
16449  PLFLT *arg2 = (PLFLT *) 0 ;
16450  PLFLT *arg3 = (PLFLT *) 0 ;
16451  PLFLT *arg4 = (PLFLT *) 0 ;
16452  Matrix temp1 ;
16453  Matrix temp3 ;
16454  Matrix temp4 ;
16455  octave_value_list _out;
16456  octave_value_list *_outp=&_out;
16457  octave_value _outv;
16458 
16459  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
16460  SWIG_fail;
16461  }
16462  {
16463  if ( _n_dims( args(0) ) > 1 )
16464  {
16465  error( "argument must be a scalar or vector" ); SWIG_fail;
16466  }
16467  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16468  temp1 = args(0).matrix_value();
16469  arg2 = &temp1( 0, 0 );
16470  }
16471  {
16472  if ( _n_dims( args(1) ) > 1 )
16473  {
16474  error( "argument must be a scalar or vector" ); SWIG_fail;
16475  }
16476  if ( _dim( args(1), 0 ) != Alen )
16477  {
16478  error( "argument vectors must be same length" ); SWIG_fail;
16479  }
16480  temp3 = args(1).matrix_value();
16481  arg3 = &temp3( 0, 0 );
16482  }
16483  {
16484  if ( _n_dims( args(2) ) > 1 )
16485  {
16486  error( "argument must be a scalar or vector" ); SWIG_fail;
16487  }
16488  if ( _dim( args(2), 0 ) != Alen )
16489  {
16490  error( "argument vectors must be same length" ); SWIG_fail;
16491  }
16492  temp4 = args(2).matrix_value();
16493  arg4 = &temp4( 0, 0 );
16494  }
16495  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16496  _outv = octave_value();
16497  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16498  {
16499 
16500  }
16501  {
16502 
16503  }
16504  {
16505 
16506  }
16507 fail:
16508  return _out;
16509 }
16510 
16511 
16512 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
16513  octave_value_list _out;
16514  octave_value_list *_outp=&_out;
16515  octave_value _outv;
16516 
16517  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
16518  SWIG_fail;
16519  }
16520  plfamadv();
16521  _outv = octave_value();
16522  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16523 fail:
16524  return _out;
16525 }
16526 
16527 
16528 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
16529  PLINT arg1 ;
16530  PLFLT *arg2 = (PLFLT *) 0 ;
16531  PLFLT *arg3 = (PLFLT *) 0 ;
16532  Matrix temp1 ;
16533  Matrix temp3 ;
16534  octave_value_list _out;
16535  octave_value_list *_outp=&_out;
16536  octave_value _outv;
16537 
16538  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
16539  SWIG_fail;
16540  }
16541  {
16542  if ( _n_dims( args(0) ) > 1 )
16543  {
16544  error( "argument must be a scalar or vector" ); SWIG_fail;
16545  }
16546  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16547  temp1 = args(0).matrix_value();
16548  arg2 = &temp1( 0, 0 );
16549  }
16550  {
16551  if ( _n_dims( args(1) ) > 1 )
16552  {
16553  error( "argument must be a scalar or vector" ); SWIG_fail;
16554  }
16555  if ( _dim( args(1), 0 ) != Alen )
16556  {
16557  error( "argument vectors must be same length" ); SWIG_fail;
16558  }
16559  temp3 = args(1).matrix_value();
16560  arg3 = &temp3( 0, 0 );
16561  }
16562  plfill(arg1,(double const *)arg2,(double const *)arg3);
16563  _outv = octave_value();
16564  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16565  {
16566 
16567  }
16568  {
16569 
16570  }
16571 fail:
16572  return _out;
16573 }
16574 
16575 
16576 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
16577  PLINT arg1 ;
16578  PLFLT *arg2 = (PLFLT *) 0 ;
16579  PLFLT *arg3 = (PLFLT *) 0 ;
16580  PLFLT *arg4 = (PLFLT *) 0 ;
16581  Matrix temp1 ;
16582  Matrix temp3 ;
16583  Matrix temp4 ;
16584  octave_value_list _out;
16585  octave_value_list *_outp=&_out;
16586  octave_value _outv;
16587 
16588  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
16589  SWIG_fail;
16590  }
16591  {
16592  if ( _n_dims( args(0) ) > 1 )
16593  {
16594  error( "argument must be a scalar or vector" ); SWIG_fail;
16595  }
16596  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16597  temp1 = args(0).matrix_value();
16598  arg2 = &temp1( 0, 0 );
16599  }
16600  {
16601  if ( _n_dims( args(1) ) > 1 )
16602  {
16603  error( "argument must be a scalar or vector" ); SWIG_fail;
16604  }
16605  if ( _dim( args(1), 0 ) != Alen )
16606  {
16607  error( "argument vectors must be same length" ); SWIG_fail;
16608  }
16609  temp3 = args(1).matrix_value();
16610  arg3 = &temp3( 0, 0 );
16611  }
16612  {
16613  if ( _n_dims( args(2) ) > 1 )
16614  {
16615  error( "argument must be a scalar or vector" ); SWIG_fail;
16616  }
16617  if ( _dim( args(2), 0 ) != Alen )
16618  {
16619  error( "argument vectors must be same length" ); SWIG_fail;
16620  }
16621  temp4 = args(2).matrix_value();
16622  arg4 = &temp4( 0, 0 );
16623  }
16624  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16625  _outv = octave_value();
16626  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16627  {
16628 
16629  }
16630  {
16631 
16632  }
16633  {
16634 
16635  }
16636 fail:
16637  return _out;
16638 }
16639 
16640 
16641 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
16642  PLINT arg1 ;
16643  PLFLT *arg2 = (PLFLT *) 0 ;
16644  PLFLT *arg3 = (PLFLT *) 0 ;
16645  PLFLT arg4 ;
16646  Matrix temp1 ;
16647  Matrix temp3 ;
16648  double val4 ;
16649  int ecode4 = 0 ;
16650  octave_value_list _out;
16651  octave_value_list *_outp=&_out;
16652  octave_value _outv;
16653 
16654  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
16655  SWIG_fail;
16656  }
16657  {
16658  if ( _n_dims( args(0) ) > 1 )
16659  {
16660  error( "argument must be a scalar or vector" ); SWIG_fail;
16661  }
16662  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16663  temp1 = args(0).matrix_value();
16664  arg2 = &temp1( 0, 0 );
16665  }
16666  {
16667  if ( _n_dims( args(1) ) > 1 )
16668  {
16669  error( "argument must be a scalar or vector" ); SWIG_fail;
16670  }
16671  if ( _dim( args(1), 0 ) != Alen )
16672  {
16673  error( "argument vectors must be same length" ); SWIG_fail;
16674  }
16675  temp3 = args(1).matrix_value();
16676  arg3 = &temp3( 0, 0 );
16677  }
16678  ecode4 = SWIG_AsVal_double(args(2), &val4);
16679  if (!SWIG_IsOK(ecode4)) {
16680  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
16681  }
16682  arg4 = (PLFLT)(val4);
16683  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
16684  _outv = octave_value();
16685  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16686  {
16687 
16688  }
16689  {
16690 
16691  }
16692 fail:
16693  return _out;
16694 }
16695 
16696 
16697 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
16698  octave_value_list _out;
16699  octave_value_list *_outp=&_out;
16700  octave_value _outv;
16701 
16702  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
16703  SWIG_fail;
16704  }
16705  plflush();
16706  _outv = octave_value();
16707  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16708 fail:
16709  return _out;
16710 }
16711 
16712 
16713 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
16714  PLINT arg1 ;
16715  int val1 ;
16716  int ecode1 = 0 ;
16717  octave_value_list _out;
16718  octave_value_list *_outp=&_out;
16719  octave_value _outv;
16720 
16721  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
16722  SWIG_fail;
16723  }
16724  ecode1 = SWIG_AsVal_int(args(0), &val1);
16725  if (!SWIG_IsOK(ecode1)) {
16726  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
16727  }
16728  arg1 = (PLINT)(val1);
16729  plfont(arg1);
16730  _outv = octave_value();
16731  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16732 fail:
16733  return _out;
16734 }
16735 
16736 
16737 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
16738  PLINT arg1 ;
16739  int val1 ;
16740  int ecode1 = 0 ;
16741  octave_value_list _out;
16742  octave_value_list *_outp=&_out;
16743  octave_value _outv;
16744 
16745  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
16746  SWIG_fail;
16747  }
16748  ecode1 = SWIG_AsVal_int(args(0), &val1);
16749  if (!SWIG_IsOK(ecode1)) {
16750  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
16751  }
16752  arg1 = (PLINT)(val1);
16753  plfontld(arg1);
16754  _outv = octave_value();
16755  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16756 fail:
16757  return _out;
16758 }
16759 
16760 
16761 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
16762  PLFLT *arg1 = (PLFLT *) 0 ;
16763  PLFLT *arg2 = (PLFLT *) 0 ;
16764  PLFLT temp1 ;
16765  int res1 = SWIG_TMPOBJ ;
16766  PLFLT temp2 ;
16767  int res2 = SWIG_TMPOBJ ;
16768  octave_value_list _out;
16769  octave_value_list *_outp=&_out;
16770  octave_value _outv;
16771 
16772  arg1 = &temp1;
16773  arg2 = &temp2;
16774  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
16775  SWIG_fail;
16776  }
16777  plgchr(arg1,arg2);
16778  _outv = octave_value();
16779  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16780  if (SWIG_IsTmpObj(res1)) {
16781  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16782  } else {
16783  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16784  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16785  }
16786  if (SWIG_IsTmpObj(res2)) {
16787  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16788  } else {
16789  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16790  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16791  }
16792 fail:
16793  return _out;
16794 }
16795 
16796 
16797 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
16798  PLINT arg1 ;
16799  PLINT *arg2 = (PLINT *) 0 ;
16800  PLINT *arg3 = (PLINT *) 0 ;
16801  PLINT *arg4 = (PLINT *) 0 ;
16802  int val1 ;
16803  int ecode1 = 0 ;
16804  PLINT temp2 ;
16805  int res2 = SWIG_TMPOBJ ;
16806  PLINT temp3 ;
16807  int res3 = SWIG_TMPOBJ ;
16808  PLINT temp4 ;
16809  int res4 = SWIG_TMPOBJ ;
16810  octave_value_list _out;
16811  octave_value_list *_outp=&_out;
16812  octave_value _outv;
16813 
16814  arg2 = &temp2;
16815  arg3 = &temp3;
16816  arg4 = &temp4;
16817  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
16818  SWIG_fail;
16819  }
16820  ecode1 = SWIG_AsVal_int(args(0), &val1);
16821  if (!SWIG_IsOK(ecode1)) {
16822  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
16823  }
16824  arg1 = (PLINT)(val1);
16825  plgcol0(arg1,arg2,arg3,arg4);
16826  _outv = octave_value();
16827  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16828  if (SWIG_IsTmpObj(res2)) {
16829  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16830  } else {
16831  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16832  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16833  }
16834  if (SWIG_IsTmpObj(res3)) {
16835  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16836  } else {
16837  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16838  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16839  }
16840  if (SWIG_IsTmpObj(res4)) {
16841  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16842  } else {
16843  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16844  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16845  }
16846 fail:
16847  return _out;
16848 }
16849 
16850 
16851 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
16852  PLINT arg1 ;
16853  PLINT *arg2 = (PLINT *) 0 ;
16854  PLINT *arg3 = (PLINT *) 0 ;
16855  PLINT *arg4 = (PLINT *) 0 ;
16856  PLFLT *arg5 = (PLFLT *) 0 ;
16857  int val1 ;
16858  int ecode1 = 0 ;
16859  PLINT temp2 ;
16860  int res2 = SWIG_TMPOBJ ;
16861  PLINT temp3 ;
16862  int res3 = SWIG_TMPOBJ ;
16863  PLINT temp4 ;
16864  int res4 = SWIG_TMPOBJ ;
16865  PLFLT temp5 ;
16866  int res5 = SWIG_TMPOBJ ;
16867  octave_value_list _out;
16868  octave_value_list *_outp=&_out;
16869  octave_value _outv;
16870 
16871  arg2 = &temp2;
16872  arg3 = &temp3;
16873  arg4 = &temp4;
16874  arg5 = &temp5;
16875  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
16876  SWIG_fail;
16877  }
16878  ecode1 = SWIG_AsVal_int(args(0), &val1);
16879  if (!SWIG_IsOK(ecode1)) {
16880  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
16881  }
16882  arg1 = (PLINT)(val1);
16883  plgcol0a(arg1,arg2,arg3,arg4,arg5);
16884  _outv = octave_value();
16885  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16886  if (SWIG_IsTmpObj(res2)) {
16887  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16888  } else {
16889  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16890  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16891  }
16892  if (SWIG_IsTmpObj(res3)) {
16893  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16894  } else {
16895  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16896  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16897  }
16898  if (SWIG_IsTmpObj(res4)) {
16899  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16900  } else {
16901  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16902  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16903  }
16904  if (SWIG_IsTmpObj(res5)) {
16905  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
16906  } else {
16907  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16908  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
16909  }
16910 fail:
16911  return _out;
16912 }
16913 
16914 
16915 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
16916  PLINT *arg1 = (PLINT *) 0 ;
16917  PLINT *arg2 = (PLINT *) 0 ;
16918  PLINT *arg3 = (PLINT *) 0 ;
16919  PLINT temp1 ;
16920  int res1 = SWIG_TMPOBJ ;
16921  PLINT temp2 ;
16922  int res2 = SWIG_TMPOBJ ;
16923  PLINT temp3 ;
16924  int res3 = SWIG_TMPOBJ ;
16925  octave_value_list _out;
16926  octave_value_list *_outp=&_out;
16927  octave_value _outv;
16928 
16929  arg1 = &temp1;
16930  arg2 = &temp2;
16931  arg3 = &temp3;
16932  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
16933  SWIG_fail;
16934  }
16935  plgcolbg(arg1,arg2,arg3);
16936  _outv = octave_value();
16937  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16938  if (SWIG_IsTmpObj(res1)) {
16939  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16940  } else {
16941  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16942  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16943  }
16944  if (SWIG_IsTmpObj(res2)) {
16945  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16946  } else {
16947  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16948  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16949  }
16950  if (SWIG_IsTmpObj(res3)) {
16951  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16952  } else {
16953  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16954  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16955  }
16956 fail:
16957  return _out;
16958 }
16959 
16960 
16961 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
16962  PLINT *arg1 = (PLINT *) 0 ;
16963  PLINT *arg2 = (PLINT *) 0 ;
16964  PLINT *arg3 = (PLINT *) 0 ;
16965  PLFLT *arg4 = (PLFLT *) 0 ;
16966  PLINT temp1 ;
16967  int res1 = SWIG_TMPOBJ ;
16968  PLINT temp2 ;
16969  int res2 = SWIG_TMPOBJ ;
16970  PLINT temp3 ;
16971  int res3 = SWIG_TMPOBJ ;
16972  PLFLT temp4 ;
16973  int res4 = SWIG_TMPOBJ ;
16974  octave_value_list _out;
16975  octave_value_list *_outp=&_out;
16976  octave_value _outv;
16977 
16978  arg1 = &temp1;
16979  arg2 = &temp2;
16980  arg3 = &temp3;
16981  arg4 = &temp4;
16982  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
16983  SWIG_fail;
16984  }
16985  plgcolbga(arg1,arg2,arg3,arg4);
16986  _outv = octave_value();
16987  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16988  if (SWIG_IsTmpObj(res1)) {
16989  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16990  } else {
16991  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16992  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16993  }
16994  if (SWIG_IsTmpObj(res2)) {
16995  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16996  } else {
16997  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16998  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16999  }
17000  if (SWIG_IsTmpObj(res3)) {
17001  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17002  } else {
17003  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17004  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17005  }
17006  if (SWIG_IsTmpObj(res4)) {
17007  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17008  } else {
17009  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17010  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17011  }
17012 fail:
17013  return _out;
17014 }
17015 
17016 
17017 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
17018  PLINT *arg1 = (PLINT *) 0 ;
17019  PLINT temp1 ;
17020  int res1 = SWIG_TMPOBJ ;
17021  octave_value_list _out;
17022  octave_value_list *_outp=&_out;
17023  octave_value _outv;
17024 
17025  arg1 = &temp1;
17026  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
17027  SWIG_fail;
17028  }
17029  plgcompression(arg1);
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_int((*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_int, new_flags));
17037  }
17038 fail:
17039  return _out;
17040 }
17041 
17042 
17043 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
17044  char *arg1 = (char *) 0 ;
17045  octave_value_list retval1 ;
17046  octave_value_list _out;
17047  octave_value_list *_outp=&_out;
17048  octave_value _outv;
17049 
17050  {
17051  // Check if version >= 3.4.0
17052 # if OCTAVE_API_VERSION_NUMBER < 45
17053  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17054 # else
17055  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17056 # endif
17057  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17058  }
17059  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
17060  SWIG_fail;
17061  }
17062  plgdev(arg1);
17063  _outv = octave_value();
17064  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17065  {
17066  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17067  }
17068 fail:
17069  return _out;
17070 }
17071 
17072 
17073 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
17074  PLFLT *arg1 = (PLFLT *) 0 ;
17075  PLFLT *arg2 = (PLFLT *) 0 ;
17076  PLFLT *arg3 = (PLFLT *) 0 ;
17077  PLFLT *arg4 = (PLFLT *) 0 ;
17078  PLFLT temp1 ;
17079  int res1 = SWIG_TMPOBJ ;
17080  PLFLT temp2 ;
17081  int res2 = SWIG_TMPOBJ ;
17082  PLFLT temp3 ;
17083  int res3 = SWIG_TMPOBJ ;
17084  PLFLT temp4 ;
17085  int res4 = SWIG_TMPOBJ ;
17086  octave_value_list _out;
17087  octave_value_list *_outp=&_out;
17088  octave_value _outv;
17089 
17090  arg1 = &temp1;
17091  arg2 = &temp2;
17092  arg3 = &temp3;
17093  arg4 = &temp4;
17094  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
17095  SWIG_fail;
17096  }
17097  plgdidev(arg1,arg2,arg3,arg4);
17098  _outv = octave_value();
17099  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17100  if (SWIG_IsTmpObj(res1)) {
17101  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17102  } else {
17103  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17104  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17105  }
17106  if (SWIG_IsTmpObj(res2)) {
17107  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17108  } else {
17109  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17110  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17111  }
17112  if (SWIG_IsTmpObj(res3)) {
17113  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17114  } else {
17115  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17116  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17117  }
17118  if (SWIG_IsTmpObj(res4)) {
17119  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17120  } else {
17121  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17122  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17123  }
17124 fail:
17125  return _out;
17126 }
17127 
17128 
17129 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
17130  PLFLT *arg1 = (PLFLT *) 0 ;
17131  PLFLT temp1 ;
17132  int res1 = SWIG_TMPOBJ ;
17133  octave_value_list _out;
17134  octave_value_list *_outp=&_out;
17135  octave_value _outv;
17136 
17137  arg1 = &temp1;
17138  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
17139  SWIG_fail;
17140  }
17141  plgdiori(arg1);
17142  _outv = octave_value();
17143  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17144  if (SWIG_IsTmpObj(res1)) {
17145  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17146  } else {
17147  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17148  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17149  }
17150 fail:
17151  return _out;
17152 }
17153 
17154 
17155 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
17156  PLFLT *arg1 = (PLFLT *) 0 ;
17157  PLFLT *arg2 = (PLFLT *) 0 ;
17158  PLFLT *arg3 = (PLFLT *) 0 ;
17159  PLFLT *arg4 = (PLFLT *) 0 ;
17160  PLFLT temp1 ;
17161  int res1 = SWIG_TMPOBJ ;
17162  PLFLT temp2 ;
17163  int res2 = SWIG_TMPOBJ ;
17164  PLFLT temp3 ;
17165  int res3 = SWIG_TMPOBJ ;
17166  PLFLT temp4 ;
17167  int res4 = SWIG_TMPOBJ ;
17168  octave_value_list _out;
17169  octave_value_list *_outp=&_out;
17170  octave_value _outv;
17171 
17172  arg1 = &temp1;
17173  arg2 = &temp2;
17174  arg3 = &temp3;
17175  arg4 = &temp4;
17176  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
17177  SWIG_fail;
17178  }
17179  plgdiplt(arg1,arg2,arg3,arg4);
17180  _outv = octave_value();
17181  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17182  if (SWIG_IsTmpObj(res1)) {
17183  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17184  } else {
17185  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17186  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17187  }
17188  if (SWIG_IsTmpObj(res2)) {
17189  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17190  } else {
17191  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17192  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17193  }
17194  if (SWIG_IsTmpObj(res3)) {
17195  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17196  } else {
17197  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17198  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17199  }
17200  if (SWIG_IsTmpObj(res4)) {
17201  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17202  } else {
17203  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17204  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17205  }
17206 fail:
17207  return _out;
17208 }
17209 
17210 
17211 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
17212  PLINT *arg1 = (PLINT *) 0 ;
17213  PLINT *arg2 = (PLINT *) 0 ;
17214  PLINT *arg3 = (PLINT *) 0 ;
17215  PLINT temp1 ;
17216  int res1 = SWIG_TMPOBJ ;
17217  PLINT temp2 ;
17218  int res2 = SWIG_TMPOBJ ;
17219  PLINT temp3 ;
17220  int res3 = SWIG_TMPOBJ ;
17221  octave_value_list _out;
17222  octave_value_list *_outp=&_out;
17223  octave_value _outv;
17224 
17225  arg1 = &temp1;
17226  arg2 = &temp2;
17227  arg3 = &temp3;
17228  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
17229  SWIG_fail;
17230  }
17231  plgfam(arg1,arg2,arg3);
17232  _outv = octave_value();
17233  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17234  if (SWIG_IsTmpObj(res1)) {
17235  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17236  } else {
17237  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17238  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17239  }
17240  if (SWIG_IsTmpObj(res2)) {
17241  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17242  } else {
17243  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17244  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17245  }
17246  if (SWIG_IsTmpObj(res3)) {
17247  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17248  } else {
17249  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17250  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17251  }
17252 fail:
17253  return _out;
17254 }
17255 
17256 
17257 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
17258  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
17259  PLUNICODE temp1 ;
17260  int res1 = SWIG_TMPOBJ ;
17261  octave_value_list _out;
17262  octave_value_list *_outp=&_out;
17263  octave_value _outv;
17264 
17265  arg1 = &temp1;
17266  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
17267  SWIG_fail;
17268  }
17269  plgfci(arg1);
17270  _outv = octave_value();
17271  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17272  if (SWIG_IsTmpObj(res1)) {
17273  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
17274  } else {
17275  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17276  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
17277  }
17278 fail:
17279  return _out;
17280 }
17281 
17282 
17283 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
17284  char *arg1 = (char *) 0 ;
17285  octave_value_list retval1 ;
17286  octave_value_list _out;
17287  octave_value_list *_outp=&_out;
17288  octave_value _outv;
17289 
17290  {
17291  // Check if version >= 3.4.0
17292 # if OCTAVE_API_VERSION_NUMBER < 45
17293  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17294 # else
17295  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17296 # endif
17297  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17298  }
17299  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
17300  SWIG_fail;
17301  }
17302  plgfnam(arg1);
17303  _outv = octave_value();
17304  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17305  {
17306  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17307  }
17308 fail:
17309  return _out;
17310 }
17311 
17312 
17313 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
17314  PLINT *arg1 = (PLINT *) 0 ;
17315  PLINT *arg2 = (PLINT *) 0 ;
17316  PLINT *arg3 = (PLINT *) 0 ;
17317  PLINT temp1 ;
17318  int res1 = SWIG_TMPOBJ ;
17319  PLINT temp2 ;
17320  int res2 = SWIG_TMPOBJ ;
17321  PLINT temp3 ;
17322  int res3 = SWIG_TMPOBJ ;
17323  octave_value_list _out;
17324  octave_value_list *_outp=&_out;
17325  octave_value _outv;
17326 
17327  arg1 = &temp1;
17328  arg2 = &temp2;
17329  arg3 = &temp3;
17330  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
17331  SWIG_fail;
17332  }
17333  plgfont(arg1,arg2,arg3);
17334  _outv = octave_value();
17335  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17336  if (SWIG_IsTmpObj(res1)) {
17337  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17338  } else {
17339  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17340  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17341  }
17342  if (SWIG_IsTmpObj(res2)) {
17343  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17344  } else {
17345  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17346  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17347  }
17348  if (SWIG_IsTmpObj(res3)) {
17349  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17350  } else {
17351  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17352  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17353  }
17354 fail:
17355  return _out;
17356 }
17357 
17358 
17359 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
17360  PLINT *arg1 = (PLINT *) 0 ;
17361  PLINT temp1 ;
17362  int res1 = SWIG_TMPOBJ ;
17363  octave_value_list _out;
17364  octave_value_list *_outp=&_out;
17365  octave_value _outv;
17366 
17367  arg1 = &temp1;
17368  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
17369  SWIG_fail;
17370  }
17371  plglevel(arg1);
17372  _outv = octave_value();
17373  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17374  if (SWIG_IsTmpObj(res1)) {
17375  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17376  } else {
17377  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17378  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17379  }
17380 fail:
17381  return _out;
17382 }
17383 
17384 
17385 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
17386  PLFLT *arg1 = (PLFLT *) 0 ;
17387  PLFLT *arg2 = (PLFLT *) 0 ;
17388  PLINT *arg3 = (PLINT *) 0 ;
17389  PLINT *arg4 = (PLINT *) 0 ;
17390  PLINT *arg5 = (PLINT *) 0 ;
17391  PLINT *arg6 = (PLINT *) 0 ;
17392  PLFLT temp1 ;
17393  int res1 = SWIG_TMPOBJ ;
17394  PLFLT temp2 ;
17395  int res2 = SWIG_TMPOBJ ;
17396  PLINT temp3 ;
17397  int res3 = SWIG_TMPOBJ ;
17398  PLINT temp4 ;
17399  int res4 = SWIG_TMPOBJ ;
17400  PLINT temp5 ;
17401  int res5 = SWIG_TMPOBJ ;
17402  PLINT temp6 ;
17403  int res6 = SWIG_TMPOBJ ;
17404  octave_value_list _out;
17405  octave_value_list *_outp=&_out;
17406  octave_value _outv;
17407 
17408  arg1 = &temp1;
17409  arg2 = &temp2;
17410  arg3 = &temp3;
17411  arg4 = &temp4;
17412  arg5 = &temp5;
17413  arg6 = &temp6;
17414  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
17415  SWIG_fail;
17416  }
17417  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
17418  _outv = octave_value();
17419  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17420  if (SWIG_IsTmpObj(res1)) {
17421  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17422  } else {
17423  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17424  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17425  }
17426  if (SWIG_IsTmpObj(res2)) {
17427  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17428  } else {
17429  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17430  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17431  }
17432  if (SWIG_IsTmpObj(res3)) {
17433  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17434  } else {
17435  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17436  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17437  }
17438  if (SWIG_IsTmpObj(res4)) {
17439  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17440  } else {
17441  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17442  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17443  }
17444  if (SWIG_IsTmpObj(res5)) {
17445  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17446  } else {
17447  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17448  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17449  }
17450  if (SWIG_IsTmpObj(res6)) {
17451  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
17452  } else {
17453  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17454  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
17455  }
17456 fail:
17457  return _out;
17458 }
17459 
17460 
17461 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
17462  octave_value_list _out;
17463  octave_value_list *_outp=&_out;
17464  octave_value _outv;
17465 
17466  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
17467  SWIG_fail;
17468  }
17469  plgra();
17470  _outv = octave_value();
17471  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17472 fail:
17473  return _out;
17474 }
17475 
17476 
17477 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
17478  PLFLT *arg1 = (PLFLT *) 0 ;
17479  PLFLT *arg2 = (PLFLT *) 0 ;
17480  PLFLT *arg3 = (PLFLT *) 0 ;
17481  PLFLT *arg4 = (PLFLT *) 0 ;
17482  PLFLT temp1 ;
17483  int res1 = SWIG_TMPOBJ ;
17484  PLFLT temp2 ;
17485  int res2 = SWIG_TMPOBJ ;
17486  PLFLT temp3 ;
17487  int res3 = SWIG_TMPOBJ ;
17488  PLFLT temp4 ;
17489  int res4 = SWIG_TMPOBJ ;
17490  octave_value_list _out;
17491  octave_value_list *_outp=&_out;
17492  octave_value _outv;
17493 
17494  arg1 = &temp1;
17495  arg2 = &temp2;
17496  arg3 = &temp3;
17497  arg4 = &temp4;
17498  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
17499  SWIG_fail;
17500  }
17501  plgspa(arg1,arg2,arg3,arg4);
17502  _outv = octave_value();
17503  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17504  if (SWIG_IsTmpObj(res1)) {
17505  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17506  } else {
17507  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17508  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17509  }
17510  if (SWIG_IsTmpObj(res2)) {
17511  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17512  } else {
17513  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17514  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17515  }
17516  if (SWIG_IsTmpObj(res3)) {
17517  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17518  } else {
17519  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17520  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17521  }
17522  if (SWIG_IsTmpObj(res4)) {
17523  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17524  } else {
17525  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17526  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17527  }
17528 fail:
17529  return _out;
17530 }
17531 
17532 
17533 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
17534  PLINT *arg1 = (PLINT *) 0 ;
17535  PLINT temp1 ;
17536  int res1 = SWIG_TMPOBJ ;
17537  octave_value_list _out;
17538  octave_value_list *_outp=&_out;
17539  octave_value _outv;
17540 
17541  arg1 = &temp1;
17542  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
17543  SWIG_fail;
17544  }
17545  plgstrm(arg1);
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_int((*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_int, new_flags));
17553  }
17554 fail:
17555  return _out;
17556 }
17557 
17558 
17559 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
17560  char *arg1 = (char *) 0 ;
17561  octave_value_list retval1 ;
17562  octave_value_list _out;
17563  octave_value_list *_outp=&_out;
17564  octave_value _outv;
17565 
17566  {
17567  // Check if version >= 3.4.0
17568 # if OCTAVE_API_VERSION_NUMBER < 45
17569  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17570 # else
17571  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17572 # endif
17573  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17574  }
17575  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
17576  SWIG_fail;
17577  }
17578  plgver(arg1);
17579  _outv = octave_value();
17580  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17581  {
17582  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17583  }
17584 fail:
17585  return _out;
17586 }
17587 
17588 
17589 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
17590  PLFLT *arg1 = (PLFLT *) 0 ;
17591  PLFLT *arg2 = (PLFLT *) 0 ;
17592  PLFLT *arg3 = (PLFLT *) 0 ;
17593  PLFLT *arg4 = (PLFLT *) 0 ;
17594  PLFLT temp1 ;
17595  int res1 = SWIG_TMPOBJ ;
17596  PLFLT temp2 ;
17597  int res2 = SWIG_TMPOBJ ;
17598  PLFLT temp3 ;
17599  int res3 = SWIG_TMPOBJ ;
17600  PLFLT temp4 ;
17601  int res4 = SWIG_TMPOBJ ;
17602  octave_value_list _out;
17603  octave_value_list *_outp=&_out;
17604  octave_value _outv;
17605 
17606  arg1 = &temp1;
17607  arg2 = &temp2;
17608  arg3 = &temp3;
17609  arg4 = &temp4;
17610  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
17611  SWIG_fail;
17612  }
17613  plgvpd(arg1,arg2,arg3,arg4);
17614  _outv = octave_value();
17615  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17616  if (SWIG_IsTmpObj(res1)) {
17617  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17618  } else {
17619  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17620  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17621  }
17622  if (SWIG_IsTmpObj(res2)) {
17623  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17624  } else {
17625  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17626  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17627  }
17628  if (SWIG_IsTmpObj(res3)) {
17629  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17630  } else {
17631  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17632  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17633  }
17634  if (SWIG_IsTmpObj(res4)) {
17635  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17636  } else {
17637  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17638  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17639  }
17640 fail:
17641  return _out;
17642 }
17643 
17644 
17645 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
17646  PLFLT *arg1 = (PLFLT *) 0 ;
17647  PLFLT *arg2 = (PLFLT *) 0 ;
17648  PLFLT *arg3 = (PLFLT *) 0 ;
17649  PLFLT *arg4 = (PLFLT *) 0 ;
17650  PLFLT temp1 ;
17651  int res1 = SWIG_TMPOBJ ;
17652  PLFLT temp2 ;
17653  int res2 = SWIG_TMPOBJ ;
17654  PLFLT temp3 ;
17655  int res3 = SWIG_TMPOBJ ;
17656  PLFLT temp4 ;
17657  int res4 = SWIG_TMPOBJ ;
17658  octave_value_list _out;
17659  octave_value_list *_outp=&_out;
17660  octave_value _outv;
17661 
17662  arg1 = &temp1;
17663  arg2 = &temp2;
17664  arg3 = &temp3;
17665  arg4 = &temp4;
17666  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
17667  SWIG_fail;
17668  }
17669  plgvpw(arg1,arg2,arg3,arg4);
17670  _outv = octave_value();
17671  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17672  if (SWIG_IsTmpObj(res1)) {
17673  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17674  } else {
17675  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17676  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17677  }
17678  if (SWIG_IsTmpObj(res2)) {
17679  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17680  } else {
17681  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17682  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17683  }
17684  if (SWIG_IsTmpObj(res3)) {
17685  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17686  } else {
17687  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17688  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17689  }
17690  if (SWIG_IsTmpObj(res4)) {
17691  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17692  } else {
17693  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17694  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17695  }
17696 fail:
17697  return _out;
17698 }
17699 
17700 
17701 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
17702  PLINT *arg1 = (PLINT *) 0 ;
17703  PLINT *arg2 = (PLINT *) 0 ;
17704  PLINT temp1 ;
17705  int res1 = SWIG_TMPOBJ ;
17706  PLINT temp2 ;
17707  int res2 = SWIG_TMPOBJ ;
17708  octave_value_list _out;
17709  octave_value_list *_outp=&_out;
17710  octave_value _outv;
17711 
17712  arg1 = &temp1;
17713  arg2 = &temp2;
17714  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
17715  SWIG_fail;
17716  }
17717  plgxax(arg1,arg2);
17718  _outv = octave_value();
17719  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17720  if (SWIG_IsTmpObj(res1)) {
17721  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17722  } else {
17723  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17724  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17725  }
17726  if (SWIG_IsTmpObj(res2)) {
17727  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17728  } else {
17729  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17730  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17731  }
17732 fail:
17733  return _out;
17734 }
17735 
17736 
17737 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
17738  PLINT *arg1 = (PLINT *) 0 ;
17739  PLINT *arg2 = (PLINT *) 0 ;
17740  PLINT temp1 ;
17741  int res1 = SWIG_TMPOBJ ;
17742  PLINT temp2 ;
17743  int res2 = SWIG_TMPOBJ ;
17744  octave_value_list _out;
17745  octave_value_list *_outp=&_out;
17746  octave_value _outv;
17747 
17748  arg1 = &temp1;
17749  arg2 = &temp2;
17750  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
17751  SWIG_fail;
17752  }
17753  plgyax(arg1,arg2);
17754  _outv = octave_value();
17755  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17756  if (SWIG_IsTmpObj(res1)) {
17757  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17758  } else {
17759  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17760  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17761  }
17762  if (SWIG_IsTmpObj(res2)) {
17763  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17764  } else {
17765  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17766  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17767  }
17768 fail:
17769  return _out;
17770 }
17771 
17772 
17773 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
17774  PLINT *arg1 = (PLINT *) 0 ;
17775  PLINT *arg2 = (PLINT *) 0 ;
17776  PLINT temp1 ;
17777  int res1 = SWIG_TMPOBJ ;
17778  PLINT temp2 ;
17779  int res2 = SWIG_TMPOBJ ;
17780  octave_value_list _out;
17781  octave_value_list *_outp=&_out;
17782  octave_value _outv;
17783 
17784  arg1 = &temp1;
17785  arg2 = &temp2;
17786  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
17787  SWIG_fail;
17788  }
17789  plgzax(arg1,arg2);
17790  _outv = octave_value();
17791  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17792  if (SWIG_IsTmpObj(res1)) {
17793  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17794  } else {
17795  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17796  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17797  }
17798  if (SWIG_IsTmpObj(res2)) {
17799  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17800  } else {
17801  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17802  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17803  }
17804 fail:
17805  return _out;
17806 }
17807 
17808 
17809 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
17810  PLINT arg1 ;
17811  PLFLT *arg2 = (PLFLT *) 0 ;
17812  PLFLT arg3 ;
17813  PLFLT arg4 ;
17814  PLINT arg5 ;
17815  PLINT arg6 ;
17816  Matrix temp1 ;
17817  double val3 ;
17818  int ecode3 = 0 ;
17819  double val4 ;
17820  int ecode4 = 0 ;
17821  int val5 ;
17822  int ecode5 = 0 ;
17823  int val6 ;
17824  int ecode6 = 0 ;
17825  octave_value_list _out;
17826  octave_value_list *_outp=&_out;
17827  octave_value _outv;
17828 
17829  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
17830  SWIG_fail;
17831  }
17832  {
17833  if ( _n_dims( args(0) ) > 1 )
17834  {
17835  error( "argument must be a scalar or vector" ); SWIG_fail;
17836  }
17837  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17838  temp1 = args(0).matrix_value();
17839  arg2 = &temp1( 0, 0 );
17840  }
17841  ecode3 = SWIG_AsVal_double(args(1), &val3);
17842  if (!SWIG_IsOK(ecode3)) {
17843  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
17844  }
17845  arg3 = (PLFLT)(val3);
17846  ecode4 = SWIG_AsVal_double(args(2), &val4);
17847  if (!SWIG_IsOK(ecode4)) {
17848  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
17849  }
17850  arg4 = (PLFLT)(val4);
17851  ecode5 = SWIG_AsVal_int(args(3), &val5);
17852  if (!SWIG_IsOK(ecode5)) {
17853  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
17854  }
17855  arg5 = (PLINT)(val5);
17856  ecode6 = SWIG_AsVal_int(args(4), &val6);
17857  if (!SWIG_IsOK(ecode6)) {
17858  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
17859  }
17860  arg6 = (PLINT)(val6);
17861  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
17862  _outv = octave_value();
17863  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17864  {
17865 
17866  }
17867 fail:
17868  return _out;
17869 }
17870 
17871 
17872 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
17873  PLFLT arg1 ;
17874  PLFLT arg2 ;
17875  PLFLT arg3 ;
17876  PLFLT *arg4 = (PLFLT *) 0 ;
17877  PLFLT *arg5 = (PLFLT *) 0 ;
17878  PLFLT *arg6 = (PLFLT *) 0 ;
17879  double val1 ;
17880  int ecode1 = 0 ;
17881  double val2 ;
17882  int ecode2 = 0 ;
17883  double val3 ;
17884  int ecode3 = 0 ;
17885  PLFLT temp4 ;
17886  int res4 = SWIG_TMPOBJ ;
17887  PLFLT temp5 ;
17888  int res5 = SWIG_TMPOBJ ;
17889  PLFLT temp6 ;
17890  int res6 = SWIG_TMPOBJ ;
17891  octave_value_list _out;
17892  octave_value_list *_outp=&_out;
17893  octave_value _outv;
17894 
17895  arg4 = &temp4;
17896  arg5 = &temp5;
17897  arg6 = &temp6;
17898  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
17899  SWIG_fail;
17900  }
17901  ecode1 = SWIG_AsVal_double(args(0), &val1);
17902  if (!SWIG_IsOK(ecode1)) {
17903  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
17904  }
17905  arg1 = (PLFLT)(val1);
17906  ecode2 = SWIG_AsVal_double(args(1), &val2);
17907  if (!SWIG_IsOK(ecode2)) {
17908  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
17909  }
17910  arg2 = (PLFLT)(val2);
17911  ecode3 = SWIG_AsVal_double(args(2), &val3);
17912  if (!SWIG_IsOK(ecode3)) {
17913  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
17914  }
17915  arg3 = (PLFLT)(val3);
17916  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
17917  _outv = octave_value();
17918  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17919  if (SWIG_IsTmpObj(res4)) {
17920  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17921  } else {
17922  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17923  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17924  }
17925  if (SWIG_IsTmpObj(res5)) {
17926  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17927  } else {
17928  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17929  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17930  }
17931  if (SWIG_IsTmpObj(res6)) {
17932  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17933  } else {
17934  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17935  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17936  }
17937 fail:
17938  return _out;
17939 }
17940 
17941 
17942 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
17943  octave_value_list _out;
17944  octave_value_list *_outp=&_out;
17945  octave_value _outv;
17946 
17947  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
17948  SWIG_fail;
17949  }
17950  plinit();
17951  _outv = octave_value();
17952  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17953 fail:
17954  return _out;
17955 }
17956 
17957 
17958 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
17959  PLFLT arg1 ;
17960  PLFLT arg2 ;
17961  PLFLT arg3 ;
17962  PLFLT arg4 ;
17963  double val1 ;
17964  int ecode1 = 0 ;
17965  double val2 ;
17966  int ecode2 = 0 ;
17967  double val3 ;
17968  int ecode3 = 0 ;
17969  double val4 ;
17970  int ecode4 = 0 ;
17971  octave_value_list _out;
17972  octave_value_list *_outp=&_out;
17973  octave_value _outv;
17974 
17975  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
17976  SWIG_fail;
17977  }
17978  ecode1 = SWIG_AsVal_double(args(0), &val1);
17979  if (!SWIG_IsOK(ecode1)) {
17980  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
17981  }
17982  arg1 = (PLFLT)(val1);
17983  ecode2 = SWIG_AsVal_double(args(1), &val2);
17984  if (!SWIG_IsOK(ecode2)) {
17985  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
17986  }
17987  arg2 = (PLFLT)(val2);
17988  ecode3 = SWIG_AsVal_double(args(2), &val3);
17989  if (!SWIG_IsOK(ecode3)) {
17990  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
17991  }
17992  arg3 = (PLFLT)(val3);
17993  ecode4 = SWIG_AsVal_double(args(3), &val4);
17994  if (!SWIG_IsOK(ecode4)) {
17995  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
17996  }
17997  arg4 = (PLFLT)(val4);
17998  pljoin(arg1,arg2,arg3,arg4);
17999  _outv = octave_value();
18000  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18001 fail:
18002  return _out;
18003 }
18004 
18005 
18006 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
18007  char *arg1 = (char *) 0 ;
18008  char *arg2 = (char *) 0 ;
18009  char *arg3 = (char *) 0 ;
18010  int res1 ;
18011  char *buf1 = 0 ;
18012  int alloc1 = 0 ;
18013  int res2 ;
18014  char *buf2 = 0 ;
18015  int alloc2 = 0 ;
18016  int res3 ;
18017  char *buf3 = 0 ;
18018  int alloc3 = 0 ;
18019  octave_value_list _out;
18020  octave_value_list *_outp=&_out;
18021  octave_value _outv;
18022 
18023  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
18024  SWIG_fail;
18025  }
18026  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18027  if (!SWIG_IsOK(res1)) {
18028  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
18029  }
18030  arg1 = (char *)(buf1);
18031  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
18032  if (!SWIG_IsOK(res2)) {
18033  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
18034  }
18035  arg2 = (char *)(buf2);
18036  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
18037  if (!SWIG_IsOK(res3)) {
18038  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
18039  }
18040  arg3 = (char *)(buf3);
18041  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
18042  _outv = octave_value();
18043  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18044  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18045  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18046  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18047 fail:
18048  return _out;
18049 }
18050 
18051 
18052 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
18053  PLFLT *arg1 = (PLFLT *) 0 ;
18054  PLFLT *arg2 = (PLFLT *) 0 ;
18055  PLINT arg3 ;
18056  PLINT arg4 ;
18057  PLFLT arg5 ;
18058  PLFLT arg6 ;
18059  PLFLT arg7 ;
18060  PLINT arg8 ;
18061  PLINT arg9 ;
18062  PLINT arg10 ;
18063  PLINT arg11 ;
18064  PLINT arg12 ;
18065  PLINT arg13 ;
18066  PLINT *arg14 = (PLINT *) 0 ;
18067  PLFLT arg15 ;
18068  PLFLT arg16 ;
18069  PLFLT arg17 ;
18070  PLFLT arg18 ;
18071  PLINT *arg19 = (PLINT *) 0 ;
18072  char **arg20 = (char **) 0 ;
18073  PLINT *arg21 = (PLINT *) 0 ;
18074  PLINT *arg22 = (PLINT *) 0 ;
18075  PLFLT *arg23 = (PLFLT *) 0 ;
18076  PLFLT *arg24 = (PLFLT *) 0 ;
18077  PLINT *arg25 = (PLINT *) 0 ;
18078  PLINT *arg26 = (PLINT *) 0 ;
18079  PLFLT *arg27 = (PLFLT *) 0 ;
18080  PLINT *arg28 = (PLINT *) 0 ;
18081  PLFLT *arg29 = (PLFLT *) 0 ;
18082  PLINT *arg30 = (PLINT *) 0 ;
18083  char **arg31 = (char **) 0 ;
18084  PLFLT temp1 ;
18085  int res1 = SWIG_TMPOBJ ;
18086  PLFLT temp2 ;
18087  int res2 = SWIG_TMPOBJ ;
18088  int val3 ;
18089  int ecode3 = 0 ;
18090  int val4 ;
18091  int ecode4 = 0 ;
18092  double val5 ;
18093  int ecode5 = 0 ;
18094  double val6 ;
18095  int ecode6 = 0 ;
18096  double val7 ;
18097  int ecode7 = 0 ;
18098  int val8 ;
18099  int ecode8 = 0 ;
18100  int val9 ;
18101  int ecode9 = 0 ;
18102  int val10 ;
18103  int ecode10 = 0 ;
18104  int val11 ;
18105  int ecode11 = 0 ;
18106  int val12 ;
18107  int ecode12 = 0 ;
18108  Matrix temp13 ;
18109  double val15 ;
18110  int ecode15 = 0 ;
18111  double val16 ;
18112  int ecode16 = 0 ;
18113  double val17 ;
18114  int ecode17 = 0 ;
18115  double val18 ;
18116  int ecode18 = 0 ;
18117  Matrix temp19 ;
18118  Matrix temp21 ;
18119  Matrix temp22 ;
18120  Matrix temp23 ;
18121  Matrix temp24 ;
18122  Matrix temp25 ;
18123  Matrix temp26 ;
18124  Matrix temp27 ;
18125  Matrix temp28 ;
18126  Matrix temp29 ;
18127  Matrix temp30 ;
18128  octave_value_list _out;
18129  octave_value_list *_outp=&_out;
18130  octave_value _outv;
18131 
18132  arg1 = &temp1;
18133  arg2 = &temp2;
18134  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
18135  SWIG_fail;
18136  }
18137  ecode3 = SWIG_AsVal_int(args(0), &val3);
18138  if (!SWIG_IsOK(ecode3)) {
18139  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
18140  }
18141  arg3 = (PLINT)(val3);
18142  ecode4 = SWIG_AsVal_int(args(1), &val4);
18143  if (!SWIG_IsOK(ecode4)) {
18144  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
18145  }
18146  arg4 = (PLINT)(val4);
18147  ecode5 = SWIG_AsVal_double(args(2), &val5);
18148  if (!SWIG_IsOK(ecode5)) {
18149  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
18150  }
18151  arg5 = (PLFLT)(val5);
18152  ecode6 = SWIG_AsVal_double(args(3), &val6);
18153  if (!SWIG_IsOK(ecode6)) {
18154  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
18155  }
18156  arg6 = (PLFLT)(val6);
18157  ecode7 = SWIG_AsVal_double(args(4), &val7);
18158  if (!SWIG_IsOK(ecode7)) {
18159  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
18160  }
18161  arg7 = (PLFLT)(val7);
18162  ecode8 = SWIG_AsVal_int(args(5), &val8);
18163  if (!SWIG_IsOK(ecode8)) {
18164  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
18165  }
18166  arg8 = (PLINT)(val8);
18167  ecode9 = SWIG_AsVal_int(args(6), &val9);
18168  if (!SWIG_IsOK(ecode9)) {
18169  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
18170  }
18171  arg9 = (PLINT)(val9);
18172  ecode10 = SWIG_AsVal_int(args(7), &val10);
18173  if (!SWIG_IsOK(ecode10)) {
18174  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
18175  }
18176  arg10 = (PLINT)(val10);
18177  ecode11 = SWIG_AsVal_int(args(8), &val11);
18178  if (!SWIG_IsOK(ecode11)) {
18179  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
18180  }
18181  arg11 = (PLINT)(val11);
18182  ecode12 = SWIG_AsVal_int(args(9), &val12);
18183  if (!SWIG_IsOK(ecode12)) {
18184  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
18185  }
18186  arg12 = (PLINT)(val12);
18187  {
18188  if ( _n_dims( args(10) ) > 1 )
18189  {
18190  error( "argument must be a scalar or vector" ); SWIG_fail;
18191  }
18192  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
18193  arg14 = new PLINT[Alen];
18194  temp13 = args(10).matrix_value();
18195  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
18196  }
18197  ecode15 = SWIG_AsVal_double(args(11), &val15);
18198  if (!SWIG_IsOK(ecode15)) {
18199  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
18200  }
18201  arg15 = (PLFLT)(val15);
18202  ecode16 = SWIG_AsVal_double(args(12), &val16);
18203  if (!SWIG_IsOK(ecode16)) {
18204  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
18205  }
18206  arg16 = (PLFLT)(val16);
18207  ecode17 = SWIG_AsVal_double(args(13), &val17);
18208  if (!SWIG_IsOK(ecode17)) {
18209  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
18210  }
18211  arg17 = (PLFLT)(val17);
18212  ecode18 = SWIG_AsVal_double(args(14), &val18);
18213  if (!SWIG_IsOK(ecode18)) {
18214  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
18215  }
18216  arg18 = (PLFLT)(val18);
18217  {
18218  if ( _n_dims( args(15) ) > 1 )
18219  {
18220  error( "argument must be a scalar or vector" ); SWIG_fail;
18221  }
18222  if ( _dim( args(15), 0 ) != Alen )
18223  {
18224  error( "argument vectors must be same length" ); SWIG_fail;
18225  }
18226  temp19 = args(15).matrix_value();
18227  arg19 = new PLINT[Alen];
18228  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
18229  }
18230  {
18231  charMatrix temp_matrix;
18232  Cell temp_cell;
18233  char *tmp_cstring;
18234  std::string str;
18235  size_t max_length = 0, non_blank_length;
18236  int i, ifcell;
18237  if ( _n_dims( args(16) ) > 2 )
18238  {
18239  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
18240  }
18241  if ( !args(16).is_empty() )
18242  {
18243  if ( _dim( args(16), 0 ) != Alen )
18244  {
18245  error( "first dimension must be same length as previous vector" ); SWIG_fail;
18246  }
18247  arg20 = new char*[Alen];
18248  ifcell = args(16).is_cell();
18249  if ( ifcell )
18250  {
18251  temp_cell = args(16).cell_value();
18252  }
18253  else
18254  {
18255  temp_matrix = args(16).char_matrix_value();
18256  // Allow one extra space for null termination.
18257  max_length = _dim( args(16), 1 ) + 1;
18258  }
18259 
18260  for ( i = 0; i < Alen; i++ )
18261  {
18262  // Must copy string to "permanent" location because the string
18263  // location corresponding to tmp_cstring gets
18264  // overwritten for each iteration of loop.
18265  if ( ifcell )
18266  {
18267  if ( temp_cell.elem( i ).is_string() )
18268  {
18269  str = temp_cell.elem( i ).string_value();
18270  // leave room for null termination.
18271  max_length = str.size() + 1;
18272  tmp_cstring = (char *) str.c_str();
18273  }
18274  else
18275  {
18276  // Use null string if user attempts to pass a cell array
18277  // with a non-string element (likely an empty element
18278  // since that should be allowed by the PLplot interface
18279  // if that element is going to be unused).
18280  // leave room for null termination.
18281  max_length = 1;
18282  tmp_cstring = (char *) "";
18283  }
18284  }
18285  else
18286  {
18287  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
18288  }
18289  arg20[i] = new char[max_length];
18290  strncpy( arg20[i], tmp_cstring, max_length - 1 );
18291  arg20[i][max_length - 1] = '\0';
18292  // All the trailing blank crapola should not be needed for
18293  // string cell arrays.
18294  if ( !ifcell )
18295  {
18296  // remove trailing-blank padding that is used by the
18297  // charMatrix class to insure all strings in a given
18298  // charMatrix instance have the same length.
18299  // This transformation also removes legitimate trailing
18300  // blanks but there is nothing we can do about that
18301  // for the charMatrix class.
18302 
18303  // Look for trailing nulls first (just in case, although that
18304  // shouldn't happen if charMatrix implemented as documented)
18305  // before looking for trailing blanks.
18306  non_blank_length = max_length - 2;
18307  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
18308  {
18309  non_blank_length--;
18310  }
18311  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
18312  {
18313  non_blank_length--;
18314  }
18315  arg20[i][non_blank_length + 1] = '\0';
18316  }
18317  }
18318  }
18319  else
18320  {
18321  arg20 = NULL;
18322  }
18323  }
18324  {
18325  if ( _n_dims( args(17) ) > 1 )
18326  {
18327  error( "argument must be a scalar or vector" ); SWIG_fail;
18328  }
18329  if ( !args(17).is_empty() )
18330  {
18331  if ( _dim( args(17), 0 ) != Alen )
18332  {
18333  error( "argument vectors must be same length" ); SWIG_fail;
18334  }
18335  temp21 = args(17).matrix_value();
18336  arg21 = new PLINT[Alen];
18337  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
18338  }
18339  else
18340  {
18341  arg21 = NULL;
18342  }
18343  }
18344  {
18345  if ( _n_dims( args(18) ) > 1 )
18346  {
18347  error( "argument must be a scalar or vector" ); SWIG_fail;
18348  }
18349  if ( !args(18).is_empty() )
18350  {
18351  if ( _dim( args(18), 0 ) != Alen )
18352  {
18353  error( "argument vectors must be same length" ); SWIG_fail;
18354  }
18355  temp22 = args(18).matrix_value();
18356  arg22 = new PLINT[Alen];
18357  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
18358  }
18359  else
18360  {
18361  arg22 = NULL;
18362  }
18363  }
18364  {
18365  if ( _n_dims( args(19) ) > 1 )
18366  {
18367  error( "argument must be a scalar or vector" ); SWIG_fail;
18368  }
18369  if ( !args(19).is_empty() )
18370  {
18371  if ( _dim( args(19), 0 ) != Alen )
18372  {
18373  error( "argument vectors must be same length" ); SWIG_fail;
18374  }
18375  temp23 = args(19).matrix_value();
18376  arg23 = &temp23( 0, 0 );
18377  }
18378  else
18379  {
18380  arg23 = NULL;
18381  }
18382  }
18383  {
18384  if ( _n_dims( args(20) ) > 1 )
18385  {
18386  error( "argument must be a scalar or vector" ); SWIG_fail;
18387  }
18388  if ( !args(20).is_empty() )
18389  {
18390  if ( _dim( args(20), 0 ) != Alen )
18391  {
18392  error( "argument vectors must be same length" ); SWIG_fail;
18393  }
18394  temp24 = args(20).matrix_value();
18395  arg24 = &temp24( 0, 0 );
18396  }
18397  else
18398  {
18399  arg24 = NULL;
18400  }
18401  }
18402  {
18403  if ( _n_dims( args(21) ) > 1 )
18404  {
18405  error( "argument must be a scalar or vector" ); SWIG_fail;
18406  }
18407  if ( !args(21).is_empty() )
18408  {
18409  if ( _dim( args(21), 0 ) != Alen )
18410  {
18411  error( "argument vectors must be same length" ); SWIG_fail;
18412  }
18413  temp25 = args(21).matrix_value();
18414  arg25 = new PLINT[Alen];
18415  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
18416  }
18417  else
18418  {
18419  arg25 = NULL;
18420  }
18421  }
18422  {
18423  if ( _n_dims( args(22) ) > 1 )
18424  {
18425  error( "argument must be a scalar or vector" ); SWIG_fail;
18426  }
18427  if ( !args(22).is_empty() )
18428  {
18429  if ( _dim( args(22), 0 ) != Alen )
18430  {
18431  error( "argument vectors must be same length" ); SWIG_fail;
18432  }
18433  temp26 = args(22).matrix_value();
18434  arg26 = new PLINT[Alen];
18435  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
18436  }
18437  else
18438  {
18439  arg26 = NULL;
18440  }
18441  }
18442  {
18443  if ( _n_dims( args(23) ) > 1 )
18444  {
18445  error( "argument must be a scalar or vector" ); SWIG_fail;
18446  }
18447  if ( !args(23).is_empty() )
18448  {
18449  if ( _dim( args(23), 0 ) != Alen )
18450  {
18451  error( "argument vectors must be same length" ); SWIG_fail;
18452  }
18453  temp27 = args(23).matrix_value();
18454  arg27 = &temp27( 0, 0 );
18455  }
18456  else
18457  {
18458  arg27 = NULL;
18459  }
18460  }
18461  {
18462  if ( _n_dims( args(24) ) > 1 )
18463  {
18464  error( "argument must be a scalar or vector" ); SWIG_fail;
18465  }
18466  if ( !args(24).is_empty() )
18467  {
18468  if ( _dim( args(24), 0 ) != Alen )
18469  {
18470  error( "argument vectors must be same length" ); SWIG_fail;
18471  }
18472  temp28 = args(24).matrix_value();
18473  arg28 = new PLINT[Alen];
18474  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
18475  }
18476  else
18477  {
18478  arg28 = NULL;
18479  }
18480  }
18481  {
18482  if ( _n_dims( args(25) ) > 1 )
18483  {
18484  error( "argument must be a scalar or vector" ); SWIG_fail;
18485  }
18486  if ( !args(25).is_empty() )
18487  {
18488  if ( _dim( args(25), 0 ) != Alen )
18489  {
18490  error( "argument vectors must be same length" ); SWIG_fail;
18491  }
18492  temp29 = args(25).matrix_value();
18493  arg29 = &temp29( 0, 0 );
18494  }
18495  else
18496  {
18497  arg29 = NULL;
18498  }
18499  }
18500  {
18501  if ( _n_dims( args(26) ) > 1 )
18502  {
18503  error( "argument must be a scalar or vector" ); SWIG_fail;
18504  }
18505  if ( !args(26).is_empty() )
18506  {
18507  if ( _dim( args(26), 0 ) != Alen )
18508  {
18509  error( "argument vectors must be same length" ); SWIG_fail;
18510  }
18511  temp30 = args(26).matrix_value();
18512  arg30 = new PLINT[Alen];
18513  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
18514  }
18515  else
18516  {
18517  arg30 = NULL;
18518  }
18519  }
18520  {
18521  charMatrix temp_matrix;
18522  Cell temp_cell;
18523  char *tmp_cstring;
18524  std::string str;
18525  size_t max_length = 0, non_blank_length;
18526  int i, ifcell;
18527  if ( _n_dims( args(27) ) > 2 )
18528  {
18529  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
18530  }
18531  if ( !args(27).is_empty() )
18532  {
18533  if ( _dim( args(27), 0 ) != Alen )
18534  {
18535  error( "first dimension must be same length as previous vector" ); SWIG_fail;
18536  }
18537  arg31 = new char*[Alen];
18538  ifcell = args(27).is_cell();
18539  if ( ifcell )
18540  {
18541  temp_cell = args(27).cell_value();
18542  }
18543  else
18544  {
18545  temp_matrix = args(27).char_matrix_value();
18546  // Allow one extra space for null termination.
18547  max_length = _dim( args(27), 1 ) + 1;
18548  }
18549 
18550  for ( i = 0; i < Alen; i++ )
18551  {
18552  // Must copy string to "permanent" location because the string
18553  // location corresponding to tmp_cstring gets
18554  // overwritten for each iteration of loop.
18555  if ( ifcell )
18556  {
18557  if ( temp_cell.elem( i ).is_string() )
18558  {
18559  str = temp_cell.elem( i ).string_value();
18560  // leave room for null termination.
18561  max_length = str.size() + 1;
18562  tmp_cstring = (char *) str.c_str();
18563  }
18564  else
18565  {
18566  // Use null string if user attempts to pass a cell array
18567  // with a non-string element (likely an empty element
18568  // since that should be allowed by the PLplot interface
18569  // if that element is going to be unused).
18570  // leave room for null termination.
18571  max_length = 1;
18572  tmp_cstring = (char *) "";
18573  }
18574  }
18575  else
18576  {
18577  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
18578  }
18579  arg31[i] = new char[max_length];
18580  strncpy( arg31[i], tmp_cstring, max_length - 1 );
18581  arg31[i][max_length - 1] = '\0';
18582  // All the trailing blank crapola should not be needed for
18583  // string cell arrays.
18584  if ( !ifcell )
18585  {
18586  // remove trailing-blank padding that is used by the
18587  // charMatrix class to insure all strings in a given
18588  // charMatrix instance have the same length.
18589  // This transformation also removes legitimate trailing
18590  // blanks but there is nothing we can do about that
18591  // for the charMatrix class.
18592 
18593  // Look for trailing nulls first (just in case, although that
18594  // shouldn't happen if charMatrix implemented as documented)
18595  // before looking for trailing blanks.
18596  non_blank_length = max_length - 2;
18597  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
18598  {
18599  non_blank_length--;
18600  }
18601  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
18602  {
18603  non_blank_length--;
18604  }
18605  arg31[i][non_blank_length + 1] = '\0';
18606  }
18607  }
18608  }
18609  else
18610  {
18611  arg31 = NULL;
18612  }
18613  }
18614  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);
18615  _outv = octave_value();
18616  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18617  if (SWIG_IsTmpObj(res1)) {
18618  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18619  } else {
18620  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18621  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18622  }
18623  if (SWIG_IsTmpObj(res2)) {
18624  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18625  } else {
18626  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18627  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18628  }
18629  {
18630  delete [] arg14;
18631  }
18632  {
18633  delete [] arg19;
18634  }
18635  {
18636  int i;
18637  if ( arg20 != NULL )
18638  {
18639  for ( i = 0; i < Alen; i++ )
18640  {
18641  delete[] arg20[i];
18642  }
18643  delete[] arg20;
18644  }
18645  }
18646  {
18647  if ( arg21 != NULL )
18648  delete [] arg21;
18649  }
18650  {
18651  if ( arg22 != NULL )
18652  delete [] arg22;
18653  }
18654  {
18655 
18656  }
18657  {
18658 
18659  }
18660  {
18661  if ( arg25 != NULL )
18662  delete [] arg25;
18663  }
18664  {
18665  if ( arg26 != NULL )
18666  delete [] arg26;
18667  }
18668  {
18669 
18670  }
18671  {
18672  if ( arg28 != NULL )
18673  delete [] arg28;
18674  }
18675  {
18676 
18677  }
18678  {
18679  if ( arg30 != NULL )
18680  delete [] arg30;
18681  }
18682  {
18683  int i;
18684  if ( arg31 != NULL )
18685  {
18686  for ( i = 0; i < Alen; i++ )
18687  {
18688  delete[] arg31[i];
18689  }
18690  delete[] arg31;
18691  }
18692  }
18693 fail:
18694  return _out;
18695 }
18696 
18697 
18698 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
18699  PLFLT arg1 ;
18700  PLFLT arg2 ;
18701  PLFLT arg3 ;
18702  double val1 ;
18703  int ecode1 = 0 ;
18704  double val2 ;
18705  int ecode2 = 0 ;
18706  double val3 ;
18707  int ecode3 = 0 ;
18708  octave_value_list _out;
18709  octave_value_list *_outp=&_out;
18710  octave_value _outv;
18711 
18712  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
18713  SWIG_fail;
18714  }
18715  ecode1 = SWIG_AsVal_double(args(0), &val1);
18716  if (!SWIG_IsOK(ecode1)) {
18717  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
18718  }
18719  arg1 = (PLFLT)(val1);
18720  ecode2 = SWIG_AsVal_double(args(1), &val2);
18721  if (!SWIG_IsOK(ecode2)) {
18722  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
18723  }
18724  arg2 = (PLFLT)(val2);
18725  ecode3 = SWIG_AsVal_double(args(2), &val3);
18726  if (!SWIG_IsOK(ecode3)) {
18727  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
18728  }
18729  arg3 = (PLFLT)(val3);
18730  pllightsource(arg1,arg2,arg3);
18731  _outv = octave_value();
18732  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18733 fail:
18734  return _out;
18735 }
18736 
18737 
18738 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
18739  PLINT arg1 ;
18740  PLFLT *arg2 = (PLFLT *) 0 ;
18741  PLFLT *arg3 = (PLFLT *) 0 ;
18742  Matrix temp1 ;
18743  Matrix temp3 ;
18744  octave_value_list _out;
18745  octave_value_list *_outp=&_out;
18746  octave_value _outv;
18747 
18748  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
18749  SWIG_fail;
18750  }
18751  {
18752  if ( _n_dims( args(0) ) > 1 )
18753  {
18754  error( "argument must be a scalar or vector" ); SWIG_fail;
18755  }
18756  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18757  temp1 = args(0).matrix_value();
18758  arg2 = &temp1( 0, 0 );
18759  }
18760  {
18761  if ( _n_dims( args(1) ) > 1 )
18762  {
18763  error( "argument must be a scalar or vector" ); SWIG_fail;
18764  }
18765  if ( _dim( args(1), 0 ) != Alen )
18766  {
18767  error( "argument vectors must be same length" ); SWIG_fail;
18768  }
18769  temp3 = args(1).matrix_value();
18770  arg3 = &temp3( 0, 0 );
18771  }
18772  plline(arg1,(double const *)arg2,(double const *)arg3);
18773  _outv = octave_value();
18774  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18775  {
18776 
18777  }
18778  {
18779 
18780  }
18781 fail:
18782  return _out;
18783 }
18784 
18785 
18786 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
18787  PLINT arg1 ;
18788  PLFLT *arg2 = (PLFLT *) 0 ;
18789  PLFLT *arg3 = (PLFLT *) 0 ;
18790  PLFLT *arg4 = (PLFLT *) 0 ;
18791  Matrix temp1 ;
18792  Matrix temp3 ;
18793  Matrix temp4 ;
18794  octave_value_list _out;
18795  octave_value_list *_outp=&_out;
18796  octave_value _outv;
18797 
18798  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
18799  SWIG_fail;
18800  }
18801  {
18802  if ( _n_dims( args(0) ) > 1 )
18803  {
18804  error( "argument must be a scalar or vector" ); SWIG_fail;
18805  }
18806  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18807  temp1 = args(0).matrix_value();
18808  arg2 = &temp1( 0, 0 );
18809  }
18810  {
18811  if ( _n_dims( args(1) ) > 1 )
18812  {
18813  error( "argument must be a scalar or vector" ); SWIG_fail;
18814  }
18815  if ( _dim( args(1), 0 ) != Alen )
18816  {
18817  error( "argument vectors must be same length" ); SWIG_fail;
18818  }
18819  temp3 = args(1).matrix_value();
18820  arg3 = &temp3( 0, 0 );
18821  }
18822  {
18823  if ( _n_dims( args(2) ) > 1 )
18824  {
18825  error( "argument must be a scalar or vector" ); SWIG_fail;
18826  }
18827  if ( _dim( args(2), 0 ) != Alen )
18828  {
18829  error( "argument vectors must be same length" ); SWIG_fail;
18830  }
18831  temp4 = args(2).matrix_value();
18832  arg4 = &temp4( 0, 0 );
18833  }
18834  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18835  _outv = octave_value();
18836  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18837  {
18838 
18839  }
18840  {
18841 
18842  }
18843  {
18844 
18845  }
18846 fail:
18847  return _out;
18848 }
18849 
18850 
18851 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
18852  PLINT arg1 ;
18853  int val1 ;
18854  int ecode1 = 0 ;
18855  octave_value_list _out;
18856  octave_value_list *_outp=&_out;
18857  octave_value _outv;
18858 
18859  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
18860  SWIG_fail;
18861  }
18862  ecode1 = SWIG_AsVal_int(args(0), &val1);
18863  if (!SWIG_IsOK(ecode1)) {
18864  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
18865  }
18866  arg1 = (PLINT)(val1);
18867  pllsty(arg1);
18868  _outv = octave_value();
18869  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18870 fail:
18871  return _out;
18872 }
18873 
18874 
18875 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
18876  PLINT *arg1 = (PLINT *) 0 ;
18877  PLINT temp1 ;
18878  int res1 = SWIG_TMPOBJ ;
18879  octave_value_list _out;
18880  octave_value_list *_outp=&_out;
18881  octave_value _outv;
18882 
18883  arg1 = &temp1;
18884  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
18885  SWIG_fail;
18886  }
18887  plmkstrm(arg1);
18888  _outv = octave_value();
18889  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18890  if (SWIG_IsTmpObj(res1)) {
18891  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18892  } else {
18893  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18894  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18895  }
18896 fail:
18897  return _out;
18898 }
18899 
18900 
18901 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
18902  char *arg1 = (char *) 0 ;
18903  PLFLT arg2 ;
18904  PLFLT arg3 ;
18905  PLFLT arg4 ;
18906  char *arg5 = (char *) 0 ;
18907  int res1 ;
18908  char *buf1 = 0 ;
18909  int alloc1 = 0 ;
18910  double val2 ;
18911  int ecode2 = 0 ;
18912  double val3 ;
18913  int ecode3 = 0 ;
18914  double val4 ;
18915  int ecode4 = 0 ;
18916  int res5 ;
18917  char *buf5 = 0 ;
18918  int alloc5 = 0 ;
18919  octave_value_list _out;
18920  octave_value_list *_outp=&_out;
18921  octave_value _outv;
18922 
18923  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
18924  SWIG_fail;
18925  }
18926  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18927  if (!SWIG_IsOK(res1)) {
18928  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
18929  }
18930  arg1 = (char *)(buf1);
18931  ecode2 = SWIG_AsVal_double(args(1), &val2);
18932  if (!SWIG_IsOK(ecode2)) {
18933  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
18934  }
18935  arg2 = (PLFLT)(val2);
18936  ecode3 = SWIG_AsVal_double(args(2), &val3);
18937  if (!SWIG_IsOK(ecode3)) {
18938  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
18939  }
18940  arg3 = (PLFLT)(val3);
18941  ecode4 = SWIG_AsVal_double(args(3), &val4);
18942  if (!SWIG_IsOK(ecode4)) {
18943  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
18944  }
18945  arg4 = (PLFLT)(val4);
18946  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
18947  if (!SWIG_IsOK(res5)) {
18948  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
18949  }
18950  arg5 = (char *)(buf5);
18951  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
18952  _outv = octave_value();
18953  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18954  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18955  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
18956 fail:
18957  return _out;
18958 }
18959 
18960 
18961 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
18962  char *arg1 = (char *) 0 ;
18963  PLFLT arg2 ;
18964  PLFLT arg3 ;
18965  PLFLT arg4 ;
18966  char *arg5 = (char *) 0 ;
18967  int res1 ;
18968  char *buf1 = 0 ;
18969  int alloc1 = 0 ;
18970  double val2 ;
18971  int ecode2 = 0 ;
18972  double val3 ;
18973  int ecode3 = 0 ;
18974  double val4 ;
18975  int ecode4 = 0 ;
18976  int res5 ;
18977  char *buf5 = 0 ;
18978  int alloc5 = 0 ;
18979  octave_value_list _out;
18980  octave_value_list *_outp=&_out;
18981  octave_value _outv;
18982 
18983  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
18984  SWIG_fail;
18985  }
18986  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18987  if (!SWIG_IsOK(res1)) {
18988  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
18989  }
18990  arg1 = (char *)(buf1);
18991  ecode2 = SWIG_AsVal_double(args(1), &val2);
18992  if (!SWIG_IsOK(ecode2)) {
18993  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
18994  }
18995  arg2 = (PLFLT)(val2);
18996  ecode3 = SWIG_AsVal_double(args(2), &val3);
18997  if (!SWIG_IsOK(ecode3)) {
18998  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
18999  }
19000  arg3 = (PLFLT)(val3);
19001  ecode4 = SWIG_AsVal_double(args(3), &val4);
19002  if (!SWIG_IsOK(ecode4)) {
19003  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
19004  }
19005  arg4 = (PLFLT)(val4);
19006  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
19007  if (!SWIG_IsOK(res5)) {
19008  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
19009  }
19010  arg5 = (char *)(buf5);
19011  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
19012  _outv = octave_value();
19013  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19014  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19015  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19016 fail:
19017  return _out;
19018 }
19019 
19020 
19021 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
19022  int *arg1 = (int *) 0 ;
19023  char **arg2 = (char **) 0 ;
19024  PLINT arg3 ;
19025  void *argp1 = 0 ;
19026  int res1 = 0 ;
19027  void *argp2 = 0 ;
19028  int res2 = 0 ;
19029  int val3 ;
19030  int ecode3 = 0 ;
19031  octave_value_list _out;
19032  octave_value_list *_outp=&_out;
19033  octave_value _outv;
19034  PLINT result;
19035 
19036  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
19037  SWIG_fail;
19038  }
19039  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
19040  if (!SWIG_IsOK(res1)) {
19041  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
19042  }
19043  arg1 = (int *)(argp1);
19044  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
19045  if (!SWIG_IsOK(res2)) {
19046  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char const **""'");
19047  }
19048  arg2 = (char **)(argp2);
19049  ecode3 = SWIG_AsVal_int(args(2), &val3);
19050  if (!SWIG_IsOK(ecode3)) {
19051  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
19052  }
19053  arg3 = (PLINT)(val3);
19054  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
19055  _outv = SWIG_From_int((int)(result));
19056  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19057 fail:
19058  return _out;
19059 }
19060 
19061 
19062 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
19063  PLINT arg1 ;
19064  PLINT *arg2 = (PLINT *) 0 ;
19065  PLINT *arg3 = (PLINT *) 0 ;
19066  Matrix temp1 ;
19067  Matrix temp3 ;
19068  octave_value_list _out;
19069  octave_value_list *_outp=&_out;
19070  octave_value _outv;
19071 
19072  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
19073  SWIG_fail;
19074  }
19075  {
19076  if ( _n_dims( args(0) ) > 1 )
19077  {
19078  error( "argument must be a scalar or vector" ); SWIG_fail;
19079  }
19080  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19081  arg2 = new PLINT[Alen];
19082  temp1 = args(0).matrix_value();
19083  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
19084  }
19085  {
19086  if ( _n_dims( args(1) ) > 1 )
19087  {
19088  error( "argument must be a scalar or vector" ); SWIG_fail;
19089  }
19090  if ( _dim( args(1), 0 ) != Alen )
19091  {
19092  error( "argument vectors must be same length" ); SWIG_fail;
19093  }
19094  temp3 = args(1).matrix_value();
19095  arg3 = new PLINT[Alen];
19096  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19097  }
19098  plpat(arg1,(int const *)arg2,(int const *)arg3);
19099  _outv = octave_value();
19100  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19101  {
19102  delete [] arg2;
19103  }
19104  {
19105  delete [] arg3;
19106  }
19107 fail:
19108  return _out;
19109 }
19110 
19111 
19112 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
19113  PLINT arg1 ;
19114  PLFLT arg2 ;
19115  PLFLT arg3 ;
19116  PLFLT arg4 ;
19117  PLFLT arg5 ;
19118  int val1 ;
19119  int ecode1 = 0 ;
19120  double val2 ;
19121  int ecode2 = 0 ;
19122  double val3 ;
19123  int ecode3 = 0 ;
19124  double val4 ;
19125  int ecode4 = 0 ;
19126  double val5 ;
19127  int ecode5 = 0 ;
19128  octave_value_list _out;
19129  octave_value_list *_outp=&_out;
19130  octave_value _outv;
19131 
19132  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
19133  SWIG_fail;
19134  }
19135  ecode1 = SWIG_AsVal_int(args(0), &val1);
19136  if (!SWIG_IsOK(ecode1)) {
19137  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
19138  }
19139  arg1 = (PLINT)(val1);
19140  ecode2 = SWIG_AsVal_double(args(1), &val2);
19141  if (!SWIG_IsOK(ecode2)) {
19142  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
19143  }
19144  arg2 = (PLFLT)(val2);
19145  ecode3 = SWIG_AsVal_double(args(2), &val3);
19146  if (!SWIG_IsOK(ecode3)) {
19147  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
19148  }
19149  arg3 = (PLFLT)(val3);
19150  ecode4 = SWIG_AsVal_double(args(3), &val4);
19151  if (!SWIG_IsOK(ecode4)) {
19152  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
19153  }
19154  arg4 = (PLFLT)(val4);
19155  ecode5 = SWIG_AsVal_double(args(4), &val5);
19156  if (!SWIG_IsOK(ecode5)) {
19157  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
19158  }
19159  arg5 = (PLFLT)(val5);
19160  plpath(arg1,arg2,arg3,arg4,arg5);
19161  _outv = octave_value();
19162  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19163 fail:
19164  return _out;
19165 }
19166 
19167 
19168 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
19169  PLINT arg1 ;
19170  PLFLT *arg2 = (PLFLT *) 0 ;
19171  PLFLT *arg3 = (PLFLT *) 0 ;
19172  PLINT arg4 ;
19173  Matrix temp1 ;
19174  Matrix temp3 ;
19175  int val4 ;
19176  int ecode4 = 0 ;
19177  octave_value_list _out;
19178  octave_value_list *_outp=&_out;
19179  octave_value _outv;
19180 
19181  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
19182  SWIG_fail;
19183  }
19184  {
19185  if ( _n_dims( args(0) ) > 1 )
19186  {
19187  error( "argument must be a scalar or vector" ); SWIG_fail;
19188  }
19189  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19190  temp1 = args(0).matrix_value();
19191  arg2 = &temp1( 0, 0 );
19192  }
19193  {
19194  if ( _n_dims( args(1) ) > 1 )
19195  {
19196  error( "argument must be a scalar or vector" ); SWIG_fail;
19197  }
19198  if ( _dim( args(1), 0 ) != Alen )
19199  {
19200  error( "argument vectors must be same length" ); SWIG_fail;
19201  }
19202  temp3 = args(1).matrix_value();
19203  arg3 = &temp3( 0, 0 );
19204  }
19205  ecode4 = SWIG_AsVal_int(args(2), &val4);
19206  if (!SWIG_IsOK(ecode4)) {
19207  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
19208  }
19209  arg4 = (PLINT)(val4);
19210  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
19211  _outv = octave_value();
19212  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19213  {
19214 
19215  }
19216  {
19217 
19218  }
19219 fail:
19220  return _out;
19221 }
19222 
19223 
19224 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
19225  PLINT arg1 ;
19226  PLFLT *arg2 = (PLFLT *) 0 ;
19227  PLFLT *arg3 = (PLFLT *) 0 ;
19228  PLFLT *arg4 = (PLFLT *) 0 ;
19229  PLINT arg5 ;
19230  Matrix temp1 ;
19231  Matrix temp3 ;
19232  Matrix temp4 ;
19233  int val5 ;
19234  int ecode5 = 0 ;
19235  octave_value_list _out;
19236  octave_value_list *_outp=&_out;
19237  octave_value _outv;
19238 
19239  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
19240  SWIG_fail;
19241  }
19242  {
19243  if ( _n_dims( args(0) ) > 1 )
19244  {
19245  error( "argument must be a scalar or vector" ); SWIG_fail;
19246  }
19247  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19248  temp1 = args(0).matrix_value();
19249  arg2 = &temp1( 0, 0 );
19250  }
19251  {
19252  if ( _n_dims( args(1) ) > 1 )
19253  {
19254  error( "argument must be a scalar or vector" ); SWIG_fail;
19255  }
19256  if ( _dim( args(1), 0 ) != Alen )
19257  {
19258  error( "argument vectors must be same length" ); SWIG_fail;
19259  }
19260  temp3 = args(1).matrix_value();
19261  arg3 = &temp3( 0, 0 );
19262  }
19263  {
19264  if ( _n_dims( args(2) ) > 1 )
19265  {
19266  error( "argument must be a scalar or vector" ); SWIG_fail;
19267  }
19268  if ( _dim( args(2), 0 ) != Alen )
19269  {
19270  error( "argument vectors must be same length" ); SWIG_fail;
19271  }
19272  temp4 = args(2).matrix_value();
19273  arg4 = &temp4( 0, 0 );
19274  }
19275  ecode5 = SWIG_AsVal_int(args(3), &val5);
19276  if (!SWIG_IsOK(ecode5)) {
19277  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
19278  }
19279  arg5 = (PLINT)(val5);
19280  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
19281  _outv = octave_value();
19282  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19283  {
19284 
19285  }
19286  {
19287 
19288  }
19289  {
19290 
19291  }
19292 fail:
19293  return _out;
19294 }
19295 
19296 
19297 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
19298  PLINT arg1 ;
19299  PLFLT *arg2 = (PLFLT *) 0 ;
19300  PLFLT *arg3 = (PLFLT *) 0 ;
19301  PLFLT *arg4 = (PLFLT *) 0 ;
19302  PLBOOL *arg5 = (PLBOOL *) 0 ;
19303  PLBOOL arg6 ;
19304  Matrix temp1 ;
19305  Matrix temp3 ;
19306  Matrix temp4 ;
19307  Matrix temp5 ;
19308  int val6 ;
19309  int ecode6 = 0 ;
19310  octave_value_list _out;
19311  octave_value_list *_outp=&_out;
19312  octave_value _outv;
19313 
19314  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
19315  SWIG_fail;
19316  }
19317  {
19318  if ( _n_dims( args(0) ) > 1 )
19319  {
19320  error( "argument must be a scalar or vector" ); SWIG_fail;
19321  }
19322  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19323  temp1 = args(0).matrix_value();
19324  arg2 = &temp1( 0, 0 );
19325  }
19326  {
19327  if ( _n_dims( args(1) ) > 1 )
19328  {
19329  error( "argument must be a scalar or vector" ); SWIG_fail;
19330  }
19331  if ( _dim( args(1), 0 ) != Alen )
19332  {
19333  error( "argument vectors must be same length" ); SWIG_fail;
19334  }
19335  temp3 = args(1).matrix_value();
19336  arg3 = &temp3( 0, 0 );
19337  }
19338  {
19339  if ( _n_dims( args(2) ) > 1 )
19340  {
19341  error( "argument must be a scalar or vector" ); SWIG_fail;
19342  }
19343  if ( _dim( args(2), 0 ) != Alen )
19344  {
19345  error( "argument vectors must be same length" ); SWIG_fail;
19346  }
19347  temp4 = args(2).matrix_value();
19348  arg4 = &temp4( 0, 0 );
19349  }
19350  {
19351  if ( _n_dims( args(3) ) > 1 )
19352  {
19353  error( "argument must be a scalar or vector" ); SWIG_fail;
19354  }
19355  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
19356  {
19357  error( "argument vector must be same length or one less" ); SWIG_fail;
19358  }
19359  temp5 = args(3).matrix_value();
19360  arg5 = new PLINT[Alen];
19361  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
19362  }
19363  ecode6 = SWIG_AsVal_int(args(4), &val6);
19364  if (!SWIG_IsOK(ecode6)) {
19365  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
19366  }
19367  arg6 = (PLBOOL)(val6);
19368  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
19369  _outv = octave_value();
19370  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19371  {
19372 
19373  }
19374  {
19375 
19376  }
19377  {
19378 
19379  }
19380  {
19381  delete [] arg5;
19382  }
19383 fail:
19384  return _out;
19385 }
19386 
19387 
19388 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
19389  PLINT arg1 ;
19390  PLINT arg2 ;
19391  int val1 ;
19392  int ecode1 = 0 ;
19393  int val2 ;
19394  int ecode2 = 0 ;
19395  octave_value_list _out;
19396  octave_value_list *_outp=&_out;
19397  octave_value _outv;
19398 
19399  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
19400  SWIG_fail;
19401  }
19402  ecode1 = SWIG_AsVal_int(args(0), &val1);
19403  if (!SWIG_IsOK(ecode1)) {
19404  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
19405  }
19406  arg1 = (PLINT)(val1);
19407  ecode2 = SWIG_AsVal_int(args(1), &val2);
19408  if (!SWIG_IsOK(ecode2)) {
19409  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
19410  }
19411  arg2 = (PLINT)(val2);
19412  plprec(arg1,arg2);
19413  _outv = octave_value();
19414  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19415 fail:
19416  return _out;
19417 }
19418 
19419 
19420 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
19421  PLINT arg1 ;
19422  int val1 ;
19423  int ecode1 = 0 ;
19424  octave_value_list _out;
19425  octave_value_list *_outp=&_out;
19426  octave_value _outv;
19427 
19428  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
19429  SWIG_fail;
19430  }
19431  ecode1 = SWIG_AsVal_int(args(0), &val1);
19432  if (!SWIG_IsOK(ecode1)) {
19433  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
19434  }
19435  arg1 = (PLINT)(val1);
19436  plpsty(arg1);
19437  _outv = octave_value();
19438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19439 fail:
19440  return _out;
19441 }
19442 
19443 
19444 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
19445  PLFLT arg1 ;
19446  PLFLT arg2 ;
19447  PLFLT arg3 ;
19448  PLFLT arg4 ;
19449  PLFLT arg5 ;
19450  char *arg6 = (char *) 0 ;
19451  double val1 ;
19452  int ecode1 = 0 ;
19453  double val2 ;
19454  int ecode2 = 0 ;
19455  double val3 ;
19456  int ecode3 = 0 ;
19457  double val4 ;
19458  int ecode4 = 0 ;
19459  double val5 ;
19460  int ecode5 = 0 ;
19461  int res6 ;
19462  char *buf6 = 0 ;
19463  int alloc6 = 0 ;
19464  octave_value_list _out;
19465  octave_value_list *_outp=&_out;
19466  octave_value _outv;
19467 
19468  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
19469  SWIG_fail;
19470  }
19471  ecode1 = SWIG_AsVal_double(args(0), &val1);
19472  if (!SWIG_IsOK(ecode1)) {
19473  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
19474  }
19475  arg1 = (PLFLT)(val1);
19476  ecode2 = SWIG_AsVal_double(args(1), &val2);
19477  if (!SWIG_IsOK(ecode2)) {
19478  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
19479  }
19480  arg2 = (PLFLT)(val2);
19481  ecode3 = SWIG_AsVal_double(args(2), &val3);
19482  if (!SWIG_IsOK(ecode3)) {
19483  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
19484  }
19485  arg3 = (PLFLT)(val3);
19486  ecode4 = SWIG_AsVal_double(args(3), &val4);
19487  if (!SWIG_IsOK(ecode4)) {
19488  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
19489  }
19490  arg4 = (PLFLT)(val4);
19491  ecode5 = SWIG_AsVal_double(args(4), &val5);
19492  if (!SWIG_IsOK(ecode5)) {
19493  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
19494  }
19495  arg5 = (PLFLT)(val5);
19496  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
19497  if (!SWIG_IsOK(res6)) {
19498  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
19499  }
19500  arg6 = (char *)(buf6);
19501  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
19502  _outv = octave_value();
19503  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19504  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
19505 fail:
19506  return _out;
19507 }
19508 
19509 
19510 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
19511  PLFLT arg1 ;
19512  PLFLT arg2 ;
19513  PLFLT arg3 ;
19514  PLFLT arg4 ;
19515  PLFLT arg5 ;
19516  PLFLT arg6 ;
19517  PLFLT arg7 ;
19518  PLFLT arg8 ;
19519  PLFLT arg9 ;
19520  PLFLT arg10 ;
19521  char *arg11 = (char *) 0 ;
19522  double val1 ;
19523  int ecode1 = 0 ;
19524  double val2 ;
19525  int ecode2 = 0 ;
19526  double val3 ;
19527  int ecode3 = 0 ;
19528  double val4 ;
19529  int ecode4 = 0 ;
19530  double val5 ;
19531  int ecode5 = 0 ;
19532  double val6 ;
19533  int ecode6 = 0 ;
19534  double val7 ;
19535  int ecode7 = 0 ;
19536  double val8 ;
19537  int ecode8 = 0 ;
19538  double val9 ;
19539  int ecode9 = 0 ;
19540  double val10 ;
19541  int ecode10 = 0 ;
19542  int res11 ;
19543  char *buf11 = 0 ;
19544  int alloc11 = 0 ;
19545  octave_value_list _out;
19546  octave_value_list *_outp=&_out;
19547  octave_value _outv;
19548 
19549  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
19550  SWIG_fail;
19551  }
19552  ecode1 = SWIG_AsVal_double(args(0), &val1);
19553  if (!SWIG_IsOK(ecode1)) {
19554  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
19555  }
19556  arg1 = (PLFLT)(val1);
19557  ecode2 = SWIG_AsVal_double(args(1), &val2);
19558  if (!SWIG_IsOK(ecode2)) {
19559  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
19560  }
19561  arg2 = (PLFLT)(val2);
19562  ecode3 = SWIG_AsVal_double(args(2), &val3);
19563  if (!SWIG_IsOK(ecode3)) {
19564  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
19565  }
19566  arg3 = (PLFLT)(val3);
19567  ecode4 = SWIG_AsVal_double(args(3), &val4);
19568  if (!SWIG_IsOK(ecode4)) {
19569  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
19570  }
19571  arg4 = (PLFLT)(val4);
19572  ecode5 = SWIG_AsVal_double(args(4), &val5);
19573  if (!SWIG_IsOK(ecode5)) {
19574  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
19575  }
19576  arg5 = (PLFLT)(val5);
19577  ecode6 = SWIG_AsVal_double(args(5), &val6);
19578  if (!SWIG_IsOK(ecode6)) {
19579  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
19580  }
19581  arg6 = (PLFLT)(val6);
19582  ecode7 = SWIG_AsVal_double(args(6), &val7);
19583  if (!SWIG_IsOK(ecode7)) {
19584  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
19585  }
19586  arg7 = (PLFLT)(val7);
19587  ecode8 = SWIG_AsVal_double(args(7), &val8);
19588  if (!SWIG_IsOK(ecode8)) {
19589  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
19590  }
19591  arg8 = (PLFLT)(val8);
19592  ecode9 = SWIG_AsVal_double(args(8), &val9);
19593  if (!SWIG_IsOK(ecode9)) {
19594  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
19595  }
19596  arg9 = (PLFLT)(val9);
19597  ecode10 = SWIG_AsVal_double(args(9), &val10);
19598  if (!SWIG_IsOK(ecode10)) {
19599  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
19600  }
19601  arg10 = (PLFLT)(val10);
19602  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
19603  if (!SWIG_IsOK(res11)) {
19604  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
19605  }
19606  arg11 = (char *)(buf11);
19607  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
19608  _outv = octave_value();
19609  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19610  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
19611 fail:
19612  return _out;
19613 }
19614 
19615 
19616 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
19617  octave_value_list _out;
19618  octave_value_list *_outp=&_out;
19619  octave_value _outv;
19620  PLFLT result;
19621 
19622  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
19623  SWIG_fail;
19624  }
19625  result = (PLFLT)plrandd();
19626  _outv = SWIG_From_double((double)(result));
19627  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19628 fail:
19629  return _out;
19630 }
19631 
19632 
19633 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
19634  octave_value_list _out;
19635  octave_value_list *_outp=&_out;
19636  octave_value _outv;
19637 
19638  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
19639  SWIG_fail;
19640  }
19641  plreplot();
19642  _outv = octave_value();
19643  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19644 fail:
19645  return _out;
19646 }
19647 
19648 
19649 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
19650  PLFLT arg1 ;
19651  PLFLT arg2 ;
19652  PLFLT arg3 ;
19653  PLFLT *arg4 = (PLFLT *) 0 ;
19654  PLFLT *arg5 = (PLFLT *) 0 ;
19655  PLFLT *arg6 = (PLFLT *) 0 ;
19656  double val1 ;
19657  int ecode1 = 0 ;
19658  double val2 ;
19659  int ecode2 = 0 ;
19660  double val3 ;
19661  int ecode3 = 0 ;
19662  PLFLT temp4 ;
19663  int res4 = SWIG_TMPOBJ ;
19664  PLFLT temp5 ;
19665  int res5 = SWIG_TMPOBJ ;
19666  PLFLT temp6 ;
19667  int res6 = SWIG_TMPOBJ ;
19668  octave_value_list _out;
19669  octave_value_list *_outp=&_out;
19670  octave_value _outv;
19671 
19672  arg4 = &temp4;
19673  arg5 = &temp5;
19674  arg6 = &temp6;
19675  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
19676  SWIG_fail;
19677  }
19678  ecode1 = SWIG_AsVal_double(args(0), &val1);
19679  if (!SWIG_IsOK(ecode1)) {
19680  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
19681  }
19682  arg1 = (PLFLT)(val1);
19683  ecode2 = SWIG_AsVal_double(args(1), &val2);
19684  if (!SWIG_IsOK(ecode2)) {
19685  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
19686  }
19687  arg2 = (PLFLT)(val2);
19688  ecode3 = SWIG_AsVal_double(args(2), &val3);
19689  if (!SWIG_IsOK(ecode3)) {
19690  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
19691  }
19692  arg3 = (PLFLT)(val3);
19693  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
19694  _outv = octave_value();
19695  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19696  if (SWIG_IsTmpObj(res4)) {
19697  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19698  } else {
19699  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19700  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19701  }
19702  if (SWIG_IsTmpObj(res5)) {
19703  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19704  } else {
19705  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19706  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19707  }
19708  if (SWIG_IsTmpObj(res6)) {
19709  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
19710  } else {
19711  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19712  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
19713  }
19714 fail:
19715  return _out;
19716 }
19717 
19718 
19719 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
19720  PLFLT arg1 ;
19721  PLFLT arg2 ;
19722  double val1 ;
19723  int ecode1 = 0 ;
19724  double val2 ;
19725  int ecode2 = 0 ;
19726  octave_value_list _out;
19727  octave_value_list *_outp=&_out;
19728  octave_value _outv;
19729 
19730  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
19731  SWIG_fail;
19732  }
19733  ecode1 = SWIG_AsVal_double(args(0), &val1);
19734  if (!SWIG_IsOK(ecode1)) {
19735  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
19736  }
19737  arg1 = (PLFLT)(val1);
19738  ecode2 = SWIG_AsVal_double(args(1), &val2);
19739  if (!SWIG_IsOK(ecode2)) {
19740  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
19741  }
19742  arg2 = (PLFLT)(val2);
19743  plschr(arg1,arg2);
19744  _outv = octave_value();
19745  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19746 fail:
19747  return _out;
19748 }
19749 
19750 
19751 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
19752  PLINT *arg1 = (PLINT *) 0 ;
19753  PLINT *arg2 = (PLINT *) 0 ;
19754  PLINT *arg3 = (PLINT *) 0 ;
19755  PLINT arg4 ;
19756  Matrix temp1 ;
19757  Matrix temp2 ;
19758  Matrix temp3 ;
19759  octave_value_list _out;
19760  octave_value_list *_outp=&_out;
19761  octave_value _outv;
19762 
19763  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
19764  SWIG_fail;
19765  }
19766  {
19767  if ( _n_dims( args(0) ) > 1 )
19768  {
19769  error( "argument must be a scalar or vector" ); SWIG_fail;
19770  }
19771  Alen = (PLINT) ( _dim( args(0), 0 ) );
19772  temp1 = args(0).matrix_value();
19773  arg1 = new PLINT[Alen];
19774  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19775  }
19776  {
19777  if ( _n_dims( args(1) ) > 1 )
19778  {
19779  error( "argument must be a scalar or vector" ); SWIG_fail;
19780  }
19781  if ( _dim( args(1), 0 ) != Alen )
19782  {
19783  error( "argument vectors must be same length" ); SWIG_fail;
19784  }
19785  temp2 = args(1).matrix_value();
19786  arg2 = new PLINT[Alen];
19787  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19788  }
19789  {
19790  if ( _n_dims( args(2) ) > 1 )
19791  {
19792  error( "argument must be a scalar or vector" ); SWIG_fail;
19793  }
19794  if ( _dim( args(2), 0 ) != Alen )
19795  {
19796  error( "argument vectors must be same length" ); SWIG_fail;
19797  }
19798  temp3 = args(2).matrix_value();
19799  arg3 = new PLINT[Alen];
19800  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19801  arg4 = Alen;
19802  }
19803  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
19804  _outv = octave_value();
19805  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19806  {
19807  delete [] arg1;
19808  }
19809  {
19810  delete [] arg2;
19811  }
19812  {
19813  delete [] arg3;
19814  }
19815 fail:
19816  return _out;
19817 }
19818 
19819 
19820 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
19821  PLINT *arg1 = (PLINT *) 0 ;
19822  PLINT *arg2 = (PLINT *) 0 ;
19823  PLINT *arg3 = (PLINT *) 0 ;
19824  PLFLT *arg4 = (PLFLT *) 0 ;
19825  PLINT arg5 ;
19826  Matrix temp1 ;
19827  Matrix temp2 ;
19828  Matrix temp3 ;
19829  Matrix temp4 ;
19830  octave_value_list _out;
19831  octave_value_list *_outp=&_out;
19832  octave_value _outv;
19833 
19834  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
19835  SWIG_fail;
19836  }
19837  {
19838  if ( _n_dims( args(0) ) > 1 )
19839  {
19840  error( "argument must be a scalar or vector" ); SWIG_fail;
19841  }
19842  Alen = (PLINT) ( _dim( args(0), 0 ) );
19843  temp1 = args(0).matrix_value();
19844  arg1 = new PLINT[Alen];
19845  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19846  }
19847  {
19848  if ( _n_dims( args(1) ) > 1 )
19849  {
19850  error( "argument must be a scalar or vector" ); SWIG_fail;
19851  }
19852  if ( _dim( args(1), 0 ) != Alen )
19853  {
19854  error( "argument vectors must be same length" ); SWIG_fail;
19855  }
19856  temp2 = args(1).matrix_value();
19857  arg2 = new PLINT[Alen];
19858  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19859  }
19860  {
19861  if ( _n_dims( args(2) ) > 1 )
19862  {
19863  error( "argument must be a scalar or vector" ); SWIG_fail;
19864  }
19865  if ( _dim( args(2), 0 ) != Alen )
19866  {
19867  error( "argument vectors must be same length" ); SWIG_fail;
19868  }
19869  temp3 = args(2).matrix_value();
19870  arg3 = new PLINT[Alen];
19871  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19872  }
19873  {
19874  if ( _n_dims( args(3) ) > 1 )
19875  {
19876  error( "argument must be a scalar or vector" ); SWIG_fail;
19877  }
19878  if ( _dim( args(3), 0 ) != Alen )
19879  {
19880  error( "argument vectors must be same length" ); SWIG_fail;
19881  }
19882  temp4 = args(3).matrix_value();
19883  arg4 = &temp4( 0, 0 );
19884  arg5 = (PLINT) ( _dim( args(3), 0 ) );
19885  }
19886  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
19887  _outv = octave_value();
19888  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19889  {
19890  delete [] arg1;
19891  }
19892  {
19893  delete [] arg2;
19894  }
19895  {
19896  delete [] arg3;
19897  }
19898  {
19899 
19900  }
19901 fail:
19902  return _out;
19903 }
19904 
19905 
19906 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
19907  PLINT arg1 ;
19908  int val1 ;
19909  int ecode1 = 0 ;
19910  octave_value_list _out;
19911  octave_value_list *_outp=&_out;
19912  octave_value _outv;
19913 
19914  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
19915  SWIG_fail;
19916  }
19917  ecode1 = SWIG_AsVal_int(args(0), &val1);
19918  if (!SWIG_IsOK(ecode1)) {
19919  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
19920  }
19921  arg1 = (PLINT)(val1);
19922  plscmap0n(arg1);
19923  _outv = octave_value();
19924  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19925 fail:
19926  return _out;
19927 }
19928 
19929 
19930 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
19931  PLINT *arg1 = (PLINT *) 0 ;
19932  PLINT *arg2 = (PLINT *) 0 ;
19933  PLINT *arg3 = (PLINT *) 0 ;
19934  PLINT arg4 ;
19935  Matrix temp1 ;
19936  Matrix temp2 ;
19937  Matrix temp3 ;
19938  octave_value_list _out;
19939  octave_value_list *_outp=&_out;
19940  octave_value _outv;
19941 
19942  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
19943  SWIG_fail;
19944  }
19945  {
19946  if ( _n_dims( args(0) ) > 1 )
19947  {
19948  error( "argument must be a scalar or vector" ); SWIG_fail;
19949  }
19950  Alen = (PLINT) ( _dim( args(0), 0 ) );
19951  temp1 = args(0).matrix_value();
19952  arg1 = new PLINT[Alen];
19953  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
19954  }
19955  {
19956  if ( _n_dims( args(1) ) > 1 )
19957  {
19958  error( "argument must be a scalar or vector" ); SWIG_fail;
19959  }
19960  if ( _dim( args(1), 0 ) != Alen )
19961  {
19962  error( "argument vectors must be same length" ); SWIG_fail;
19963  }
19964  temp2 = args(1).matrix_value();
19965  arg2 = new PLINT[Alen];
19966  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
19967  }
19968  {
19969  if ( _n_dims( args(2) ) > 1 )
19970  {
19971  error( "argument must be a scalar or vector" ); SWIG_fail;
19972  }
19973  if ( _dim( args(2), 0 ) != Alen )
19974  {
19975  error( "argument vectors must be same length" ); SWIG_fail;
19976  }
19977  temp3 = args(2).matrix_value();
19978  arg3 = new PLINT[Alen];
19979  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19980  arg4 = Alen;
19981  }
19982  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
19983  _outv = octave_value();
19984  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19985  {
19986  delete [] arg1;
19987  }
19988  {
19989  delete [] arg2;
19990  }
19991  {
19992  delete [] arg3;
19993  }
19994 fail:
19995  return _out;
19996 }
19997 
19998 
19999 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
20000  PLINT *arg1 = (PLINT *) 0 ;
20001  PLINT *arg2 = (PLINT *) 0 ;
20002  PLINT *arg3 = (PLINT *) 0 ;
20003  PLFLT *arg4 = (PLFLT *) 0 ;
20004  PLINT arg5 ;
20005  Matrix temp1 ;
20006  Matrix temp2 ;
20007  Matrix temp3 ;
20008  Matrix temp4 ;
20009  octave_value_list _out;
20010  octave_value_list *_outp=&_out;
20011  octave_value _outv;
20012 
20013  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
20014  SWIG_fail;
20015  }
20016  {
20017  if ( _n_dims( args(0) ) > 1 )
20018  {
20019  error( "argument must be a scalar or vector" ); SWIG_fail;
20020  }
20021  Alen = (PLINT) ( _dim( args(0), 0 ) );
20022  temp1 = args(0).matrix_value();
20023  arg1 = new PLINT[Alen];
20024  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
20025  }
20026  {
20027  if ( _n_dims( args(1) ) > 1 )
20028  {
20029  error( "argument must be a scalar or vector" ); SWIG_fail;
20030  }
20031  if ( _dim( args(1), 0 ) != Alen )
20032  {
20033  error( "argument vectors must be same length" ); SWIG_fail;
20034  }
20035  temp2 = args(1).matrix_value();
20036  arg2 = new PLINT[Alen];
20037  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
20038  }
20039  {
20040  if ( _n_dims( args(2) ) > 1 )
20041  {
20042  error( "argument must be a scalar or vector" ); SWIG_fail;
20043  }
20044  if ( _dim( args(2), 0 ) != Alen )
20045  {
20046  error( "argument vectors must be same length" ); SWIG_fail;
20047  }
20048  temp3 = args(2).matrix_value();
20049  arg3 = new PLINT[Alen];
20050  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20051  }
20052  {
20053  if ( _n_dims( args(3) ) > 1 )
20054  {
20055  error( "argument must be a scalar or vector" ); SWIG_fail;
20056  }
20057  if ( _dim( args(3), 0 ) != Alen )
20058  {
20059  error( "argument vectors must be same length" ); SWIG_fail;
20060  }
20061  temp4 = args(3).matrix_value();
20062  arg4 = &temp4( 0, 0 );
20063  arg5 = (PLINT) ( _dim( args(3), 0 ) );
20064  }
20065  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
20066  _outv = octave_value();
20067  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20068  {
20069  delete [] arg1;
20070  }
20071  {
20072  delete [] arg2;
20073  }
20074  {
20075  delete [] arg3;
20076  }
20077  {
20078 
20079  }
20080 fail:
20081  return _out;
20082 }
20083 
20084 
20085 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
20086  PLBOOL arg1 ;
20087  PLINT arg2 ;
20088  PLFLT *arg3 = (PLFLT *) 0 ;
20089  PLFLT *arg4 = (PLFLT *) 0 ;
20090  PLFLT *arg5 = (PLFLT *) 0 ;
20091  PLFLT *arg6 = (PLFLT *) 0 ;
20092  PLBOOL *arg7 = (PLBOOL *) 0 ;
20093  int val1 ;
20094  int ecode1 = 0 ;
20095  Matrix temp2 ;
20096  Matrix temp4 ;
20097  Matrix temp5 ;
20098  Matrix temp6 ;
20099  Matrix temp7 ;
20100  octave_value_list _out;
20101  octave_value_list *_outp=&_out;
20102  octave_value _outv;
20103 
20104  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
20105  SWIG_fail;
20106  }
20107  ecode1 = SWIG_AsVal_int(args(0), &val1);
20108  if (!SWIG_IsOK(ecode1)) {
20109  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
20110  }
20111  arg1 = (PLBOOL)(val1);
20112  {
20113  if ( _n_dims( args(1) ) > 1 )
20114  {
20115  error( "argument must be a scalar or vector" ); SWIG_fail;
20116  }
20117  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
20118  temp2 = args(1).matrix_value();
20119  arg3 = &temp2( 0, 0 );
20120  }
20121  {
20122  if ( _n_dims( args(2) ) > 1 )
20123  {
20124  error( "argument must be a scalar or vector" ); SWIG_fail;
20125  }
20126  if ( _dim( args(2), 0 ) != Alen )
20127  {
20128  error( "argument vectors must be same length" ); SWIG_fail;
20129  }
20130  temp4 = args(2).matrix_value();
20131  arg4 = &temp4( 0, 0 );
20132  }
20133  {
20134  if ( _n_dims( args(3) ) > 1 )
20135  {
20136  error( "argument must be a scalar or vector" ); SWIG_fail;
20137  }
20138  if ( _dim( args(3), 0 ) != Alen )
20139  {
20140  error( "argument vectors must be same length" ); SWIG_fail;
20141  }
20142  temp5 = args(3).matrix_value();
20143  arg5 = &temp5( 0, 0 );
20144  }
20145  {
20146  if ( _n_dims( args(4) ) > 1 )
20147  {
20148  error( "argument must be a scalar or vector" ); SWIG_fail;
20149  }
20150  if ( _dim( args(4), 0 ) != Alen )
20151  {
20152  error( "argument vectors must be same length" ); SWIG_fail;
20153  }
20154  temp6 = args(4).matrix_value();
20155  arg6 = &temp6( 0, 0 );
20156  }
20157  {
20158  if ( _n_dims( args(5) ) > 1 )
20159  {
20160  error( "argument must be a scalar or vector" ); SWIG_fail;
20161  }
20162  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
20163  {
20164  error( "argument vector must be same length or one less" ); SWIG_fail;
20165  }
20166  temp7 = args(5).matrix_value();
20167  arg7 = new PLINT[Alen];
20168  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
20169  }
20170  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
20171  _outv = octave_value();
20172  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20173  {
20174 
20175  }
20176  {
20177 
20178  }
20179  {
20180 
20181  }
20182  {
20183 
20184  }
20185  {
20186  delete [] arg7;
20187  }
20188 fail:
20189  return _out;
20190 }
20191 
20192 
20193 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
20194  PLBOOL arg1 ;
20195  PLINT arg2 ;
20196  PLFLT *arg3 = (PLFLT *) 0 ;
20197  PLFLT *arg4 = (PLFLT *) 0 ;
20198  PLFLT *arg5 = (PLFLT *) 0 ;
20199  PLFLT *arg6 = (PLFLT *) 0 ;
20200  PLFLT *arg7 = (PLFLT *) 0 ;
20201  PLBOOL *arg8 = (PLBOOL *) 0 ;
20202  int val1 ;
20203  int ecode1 = 0 ;
20204  Matrix temp2 ;
20205  Matrix temp4 ;
20206  Matrix temp5 ;
20207  Matrix temp6 ;
20208  Matrix temp7 ;
20209  Matrix temp8 ;
20210  octave_value_list _out;
20211  octave_value_list *_outp=&_out;
20212  octave_value _outv;
20213 
20214  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
20215  SWIG_fail;
20216  }
20217  ecode1 = SWIG_AsVal_int(args(0), &val1);
20218  if (!SWIG_IsOK(ecode1)) {
20219  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
20220  }
20221  arg1 = (PLBOOL)(val1);
20222  {
20223  if ( _n_dims( args(1) ) > 1 )
20224  {
20225  error( "argument must be a scalar or vector" ); SWIG_fail;
20226  }
20227  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
20228  temp2 = args(1).matrix_value();
20229  arg3 = &temp2( 0, 0 );
20230  }
20231  {
20232  if ( _n_dims( args(2) ) > 1 )
20233  {
20234  error( "argument must be a scalar or vector" ); SWIG_fail;
20235  }
20236  if ( _dim( args(2), 0 ) != Alen )
20237  {
20238  error( "argument vectors must be same length" ); SWIG_fail;
20239  }
20240  temp4 = args(2).matrix_value();
20241  arg4 = &temp4( 0, 0 );
20242  }
20243  {
20244  if ( _n_dims( args(3) ) > 1 )
20245  {
20246  error( "argument must be a scalar or vector" ); SWIG_fail;
20247  }
20248  if ( _dim( args(3), 0 ) != Alen )
20249  {
20250  error( "argument vectors must be same length" ); SWIG_fail;
20251  }
20252  temp5 = args(3).matrix_value();
20253  arg5 = &temp5( 0, 0 );
20254  }
20255  {
20256  if ( _n_dims( args(4) ) > 1 )
20257  {
20258  error( "argument must be a scalar or vector" ); SWIG_fail;
20259  }
20260  if ( _dim( args(4), 0 ) != Alen )
20261  {
20262  error( "argument vectors must be same length" ); SWIG_fail;
20263  }
20264  temp6 = args(4).matrix_value();
20265  arg6 = &temp6( 0, 0 );
20266  }
20267  {
20268  if ( _n_dims( args(5) ) > 1 )
20269  {
20270  error( "argument must be a scalar or vector" ); SWIG_fail;
20271  }
20272  if ( _dim( args(5), 0 ) != Alen )
20273  {
20274  error( "argument vectors must be same length" ); SWIG_fail;
20275  }
20276  temp7 = args(5).matrix_value();
20277  arg7 = &temp7( 0, 0 );
20278  }
20279  {
20280  if ( _n_dims( args(6) ) > 1 )
20281  {
20282  error( "argument must be a scalar or vector" ); SWIG_fail;
20283  }
20284  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
20285  {
20286  error( "argument vector must be same length or one less" ); SWIG_fail;
20287  }
20288  temp8 = args(6).matrix_value();
20289  arg8 = new PLINT[Alen];
20290  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
20291  }
20292  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
20293  _outv = octave_value();
20294  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20295  {
20296 
20297  }
20298  {
20299 
20300  }
20301  {
20302 
20303  }
20304  {
20305 
20306  }
20307  {
20308 
20309  }
20310  {
20311  delete [] arg8;
20312  }
20313 fail:
20314  return _out;
20315 }
20316 
20317 
20318 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
20319  PLINT arg1 ;
20320  int val1 ;
20321  int ecode1 = 0 ;
20322  octave_value_list _out;
20323  octave_value_list *_outp=&_out;
20324  octave_value _outv;
20325 
20326  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
20327  SWIG_fail;
20328  }
20329  ecode1 = SWIG_AsVal_int(args(0), &val1);
20330  if (!SWIG_IsOK(ecode1)) {
20331  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
20332  }
20333  arg1 = (PLINT)(val1);
20334  plscmap1n(arg1);
20335  _outv = octave_value();
20336  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20337 fail:
20338  return _out;
20339 }
20340 
20341 
20342 SWIG_DEFUN( plscmap1_range, _wrap_plscmap1_range, _wrap_plscmap1_range_texinfo ) {
20343  PLFLT arg1 ;
20344  PLFLT arg2 ;
20345  double val1 ;
20346  int ecode1 = 0 ;
20347  double val2 ;
20348  int ecode2 = 0 ;
20349  octave_value_list _out;
20350  octave_value_list *_outp=&_out;
20351  octave_value _outv;
20352 
20353  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
20354  SWIG_fail;
20355  }
20356  ecode1 = SWIG_AsVal_double(args(0), &val1);
20357  if (!SWIG_IsOK(ecode1)) {
20358  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
20359  }
20360  arg1 = (PLFLT)(val1);
20361  ecode2 = SWIG_AsVal_double(args(1), &val2);
20362  if (!SWIG_IsOK(ecode2)) {
20363  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
20364  }
20365  arg2 = (PLFLT)(val2);
20366  plscmap1_range(arg1,arg2);
20367  _outv = octave_value();
20368  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20369 fail:
20370  return _out;
20371 }
20372 
20373 
20374 SWIG_DEFUN( plgcmap1_range, _wrap_plgcmap1_range, _wrap_plgcmap1_range_texinfo ) {
20375  PLFLT *arg1 = (PLFLT *) 0 ;
20376  PLFLT *arg2 = (PLFLT *) 0 ;
20377  PLFLT temp1 ;
20378  int res1 = SWIG_TMPOBJ ;
20379  PLFLT temp2 ;
20380  int res2 = SWIG_TMPOBJ ;
20381  octave_value_list _out;
20382  octave_value_list *_outp=&_out;
20383  octave_value _outv;
20384 
20385  arg1 = &temp1;
20386  arg2 = &temp2;
20387  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
20388  SWIG_fail;
20389  }
20390  plgcmap1_range(arg1,arg2);
20391  _outv = octave_value();
20392  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20393  if (SWIG_IsTmpObj(res1)) {
20394  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20395  } else {
20396  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20397  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20398  }
20399  if (SWIG_IsTmpObj(res2)) {
20400  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20401  } else {
20402  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20403  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20404  }
20405 fail:
20406  return _out;
20407 }
20408 
20409 
20410 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
20411  PLINT arg1 ;
20412  PLINT arg2 ;
20413  PLINT arg3 ;
20414  PLINT arg4 ;
20415  int val1 ;
20416  int ecode1 = 0 ;
20417  int val2 ;
20418  int ecode2 = 0 ;
20419  int val3 ;
20420  int ecode3 = 0 ;
20421  int val4 ;
20422  int ecode4 = 0 ;
20423  octave_value_list _out;
20424  octave_value_list *_outp=&_out;
20425  octave_value _outv;
20426 
20427  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
20428  SWIG_fail;
20429  }
20430  ecode1 = SWIG_AsVal_int(args(0), &val1);
20431  if (!SWIG_IsOK(ecode1)) {
20432  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
20433  }
20434  arg1 = (PLINT)(val1);
20435  ecode2 = SWIG_AsVal_int(args(1), &val2);
20436  if (!SWIG_IsOK(ecode2)) {
20437  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
20438  }
20439  arg2 = (PLINT)(val2);
20440  ecode3 = SWIG_AsVal_int(args(2), &val3);
20441  if (!SWIG_IsOK(ecode3)) {
20442  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
20443  }
20444  arg3 = (PLINT)(val3);
20445  ecode4 = SWIG_AsVal_int(args(3), &val4);
20446  if (!SWIG_IsOK(ecode4)) {
20447  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
20448  }
20449  arg4 = (PLINT)(val4);
20450  plscol0(arg1,arg2,arg3,arg4);
20451  _outv = octave_value();
20452  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20453 fail:
20454  return _out;
20455 }
20456 
20457 
20458 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
20459  PLINT arg1 ;
20460  PLINT arg2 ;
20461  PLINT arg3 ;
20462  PLINT arg4 ;
20463  PLFLT arg5 ;
20464  int val1 ;
20465  int ecode1 = 0 ;
20466  int val2 ;
20467  int ecode2 = 0 ;
20468  int val3 ;
20469  int ecode3 = 0 ;
20470  int val4 ;
20471  int ecode4 = 0 ;
20472  double val5 ;
20473  int ecode5 = 0 ;
20474  octave_value_list _out;
20475  octave_value_list *_outp=&_out;
20476  octave_value _outv;
20477 
20478  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
20479  SWIG_fail;
20480  }
20481  ecode1 = SWIG_AsVal_int(args(0), &val1);
20482  if (!SWIG_IsOK(ecode1)) {
20483  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
20484  }
20485  arg1 = (PLINT)(val1);
20486  ecode2 = SWIG_AsVal_int(args(1), &val2);
20487  if (!SWIG_IsOK(ecode2)) {
20488  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
20489  }
20490  arg2 = (PLINT)(val2);
20491  ecode3 = SWIG_AsVal_int(args(2), &val3);
20492  if (!SWIG_IsOK(ecode3)) {
20493  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
20494  }
20495  arg3 = (PLINT)(val3);
20496  ecode4 = SWIG_AsVal_int(args(3), &val4);
20497  if (!SWIG_IsOK(ecode4)) {
20498  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
20499  }
20500  arg4 = (PLINT)(val4);
20501  ecode5 = SWIG_AsVal_double(args(4), &val5);
20502  if (!SWIG_IsOK(ecode5)) {
20503  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
20504  }
20505  arg5 = (PLFLT)(val5);
20506  plscol0a(arg1,arg2,arg3,arg4,arg5);
20507  _outv = octave_value();
20508  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20509 fail:
20510  return _out;
20511 }
20512 
20513 
20514 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
20515  PLINT arg1 ;
20516  PLINT arg2 ;
20517  PLINT arg3 ;
20518  int val1 ;
20519  int ecode1 = 0 ;
20520  int val2 ;
20521  int ecode2 = 0 ;
20522  int val3 ;
20523  int ecode3 = 0 ;
20524  octave_value_list _out;
20525  octave_value_list *_outp=&_out;
20526  octave_value _outv;
20527 
20528  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
20529  SWIG_fail;
20530  }
20531  ecode1 = SWIG_AsVal_int(args(0), &val1);
20532  if (!SWIG_IsOK(ecode1)) {
20533  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
20534  }
20535  arg1 = (PLINT)(val1);
20536  ecode2 = SWIG_AsVal_int(args(1), &val2);
20537  if (!SWIG_IsOK(ecode2)) {
20538  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
20539  }
20540  arg2 = (PLINT)(val2);
20541  ecode3 = SWIG_AsVal_int(args(2), &val3);
20542  if (!SWIG_IsOK(ecode3)) {
20543  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
20544  }
20545  arg3 = (PLINT)(val3);
20546  plscolbg(arg1,arg2,arg3);
20547  _outv = octave_value();
20548  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20549 fail:
20550  return _out;
20551 }
20552 
20553 
20554 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
20555  PLINT arg1 ;
20556  PLINT arg2 ;
20557  PLINT arg3 ;
20558  PLFLT arg4 ;
20559  int val1 ;
20560  int ecode1 = 0 ;
20561  int val2 ;
20562  int ecode2 = 0 ;
20563  int val3 ;
20564  int ecode3 = 0 ;
20565  double val4 ;
20566  int ecode4 = 0 ;
20567  octave_value_list _out;
20568  octave_value_list *_outp=&_out;
20569  octave_value _outv;
20570 
20571  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
20572  SWIG_fail;
20573  }
20574  ecode1 = SWIG_AsVal_int(args(0), &val1);
20575  if (!SWIG_IsOK(ecode1)) {
20576  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
20577  }
20578  arg1 = (PLINT)(val1);
20579  ecode2 = SWIG_AsVal_int(args(1), &val2);
20580  if (!SWIG_IsOK(ecode2)) {
20581  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
20582  }
20583  arg2 = (PLINT)(val2);
20584  ecode3 = SWIG_AsVal_int(args(2), &val3);
20585  if (!SWIG_IsOK(ecode3)) {
20586  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
20587  }
20588  arg3 = (PLINT)(val3);
20589  ecode4 = SWIG_AsVal_double(args(3), &val4);
20590  if (!SWIG_IsOK(ecode4)) {
20591  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
20592  }
20593  arg4 = (PLFLT)(val4);
20594  plscolbga(arg1,arg2,arg3,arg4);
20595  _outv = octave_value();
20596  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20597 fail:
20598  return _out;
20599 }
20600 
20601 
20602 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
20603  PLINT arg1 ;
20604  int val1 ;
20605  int ecode1 = 0 ;
20606  octave_value_list _out;
20607  octave_value_list *_outp=&_out;
20608  octave_value _outv;
20609 
20610  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
20611  SWIG_fail;
20612  }
20613  ecode1 = SWIG_AsVal_int(args(0), &val1);
20614  if (!SWIG_IsOK(ecode1)) {
20615  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
20616  }
20617  arg1 = (PLINT)(val1);
20618  plscolor(arg1);
20619  _outv = octave_value();
20620  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20621 fail:
20622  return _out;
20623 }
20624 
20625 
20626 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
20627  PLINT arg1 ;
20628  int val1 ;
20629  int ecode1 = 0 ;
20630  octave_value_list _out;
20631  octave_value_list *_outp=&_out;
20632  octave_value _outv;
20633 
20634  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
20635  SWIG_fail;
20636  }
20637  ecode1 = SWIG_AsVal_int(args(0), &val1);
20638  if (!SWIG_IsOK(ecode1)) {
20639  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
20640  }
20641  arg1 = (PLINT)(val1);
20642  plscompression(arg1);
20643  _outv = octave_value();
20644  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20645 fail:
20646  return _out;
20647 }
20648 
20649 
20650 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
20651  char *arg1 = (char *) 0 ;
20652  int res1 ;
20653  char *buf1 = 0 ;
20654  int alloc1 = 0 ;
20655  octave_value_list _out;
20656  octave_value_list *_outp=&_out;
20657  octave_value _outv;
20658 
20659  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
20660  SWIG_fail;
20661  }
20662  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20663  if (!SWIG_IsOK(res1)) {
20664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
20665  }
20666  arg1 = (char *)(buf1);
20667  plsdev((char const *)arg1);
20668  _outv = octave_value();
20669  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20670  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20671 fail:
20672  return _out;
20673 }
20674 
20675 
20676 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
20677  PLFLT arg1 ;
20678  PLFLT arg2 ;
20679  PLFLT arg3 ;
20680  PLFLT arg4 ;
20681  double val1 ;
20682  int ecode1 = 0 ;
20683  double val2 ;
20684  int ecode2 = 0 ;
20685  double val3 ;
20686  int ecode3 = 0 ;
20687  double val4 ;
20688  int ecode4 = 0 ;
20689  octave_value_list _out;
20690  octave_value_list *_outp=&_out;
20691  octave_value _outv;
20692 
20693  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
20694  SWIG_fail;
20695  }
20696  ecode1 = SWIG_AsVal_double(args(0), &val1);
20697  if (!SWIG_IsOK(ecode1)) {
20698  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
20699  }
20700  arg1 = (PLFLT)(val1);
20701  ecode2 = SWIG_AsVal_double(args(1), &val2);
20702  if (!SWIG_IsOK(ecode2)) {
20703  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
20704  }
20705  arg2 = (PLFLT)(val2);
20706  ecode3 = SWIG_AsVal_double(args(2), &val3);
20707  if (!SWIG_IsOK(ecode3)) {
20708  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
20709  }
20710  arg3 = (PLFLT)(val3);
20711  ecode4 = SWIG_AsVal_double(args(3), &val4);
20712  if (!SWIG_IsOK(ecode4)) {
20713  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
20714  }
20715  arg4 = (PLFLT)(val4);
20716  plsdidev(arg1,arg2,arg3,arg4);
20717  _outv = octave_value();
20718  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20719 fail:
20720  return _out;
20721 }
20722 
20723 
20724 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
20725  PLINT arg1 ;
20726  PLINT arg2 ;
20727  PLINT arg3 ;
20728  PLINT arg4 ;
20729  PLFLT arg5 ;
20730  PLFLT arg6 ;
20731  int val1 ;
20732  int ecode1 = 0 ;
20733  int val2 ;
20734  int ecode2 = 0 ;
20735  int val3 ;
20736  int ecode3 = 0 ;
20737  int val4 ;
20738  int ecode4 = 0 ;
20739  double val5 ;
20740  int ecode5 = 0 ;
20741  double val6 ;
20742  int ecode6 = 0 ;
20743  octave_value_list _out;
20744  octave_value_list *_outp=&_out;
20745  octave_value _outv;
20746 
20747  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
20748  SWIG_fail;
20749  }
20750  ecode1 = SWIG_AsVal_int(args(0), &val1);
20751  if (!SWIG_IsOK(ecode1)) {
20752  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
20753  }
20754  arg1 = (PLINT)(val1);
20755  ecode2 = SWIG_AsVal_int(args(1), &val2);
20756  if (!SWIG_IsOK(ecode2)) {
20757  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
20758  }
20759  arg2 = (PLINT)(val2);
20760  ecode3 = SWIG_AsVal_int(args(2), &val3);
20761  if (!SWIG_IsOK(ecode3)) {
20762  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
20763  }
20764  arg3 = (PLINT)(val3);
20765  ecode4 = SWIG_AsVal_int(args(3), &val4);
20766  if (!SWIG_IsOK(ecode4)) {
20767  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
20768  }
20769  arg4 = (PLINT)(val4);
20770  ecode5 = SWIG_AsVal_double(args(4), &val5);
20771  if (!SWIG_IsOK(ecode5)) {
20772  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
20773  }
20774  arg5 = (PLFLT)(val5);
20775  ecode6 = SWIG_AsVal_double(args(5), &val6);
20776  if (!SWIG_IsOK(ecode6)) {
20777  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
20778  }
20779  arg6 = (PLFLT)(val6);
20780  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
20781  _outv = octave_value();
20782  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20783 fail:
20784  return _out;
20785 }
20786 
20787 
20788 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
20789  PLFLT arg1 ;
20790  double val1 ;
20791  int ecode1 = 0 ;
20792  octave_value_list _out;
20793  octave_value_list *_outp=&_out;
20794  octave_value _outv;
20795 
20796  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
20797  SWIG_fail;
20798  }
20799  ecode1 = SWIG_AsVal_double(args(0), &val1);
20800  if (!SWIG_IsOK(ecode1)) {
20801  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
20802  }
20803  arg1 = (PLFLT)(val1);
20804  plsdiori(arg1);
20805  _outv = octave_value();
20806  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20807 fail:
20808  return _out;
20809 }
20810 
20811 
20812 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
20813  PLFLT arg1 ;
20814  PLFLT arg2 ;
20815  PLFLT arg3 ;
20816  PLFLT arg4 ;
20817  double val1 ;
20818  int ecode1 = 0 ;
20819  double val2 ;
20820  int ecode2 = 0 ;
20821  double val3 ;
20822  int ecode3 = 0 ;
20823  double val4 ;
20824  int ecode4 = 0 ;
20825  octave_value_list _out;
20826  octave_value_list *_outp=&_out;
20827  octave_value _outv;
20828 
20829  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
20830  SWIG_fail;
20831  }
20832  ecode1 = SWIG_AsVal_double(args(0), &val1);
20833  if (!SWIG_IsOK(ecode1)) {
20834  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
20835  }
20836  arg1 = (PLFLT)(val1);
20837  ecode2 = SWIG_AsVal_double(args(1), &val2);
20838  if (!SWIG_IsOK(ecode2)) {
20839  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
20840  }
20841  arg2 = (PLFLT)(val2);
20842  ecode3 = SWIG_AsVal_double(args(2), &val3);
20843  if (!SWIG_IsOK(ecode3)) {
20844  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
20845  }
20846  arg3 = (PLFLT)(val3);
20847  ecode4 = SWIG_AsVal_double(args(3), &val4);
20848  if (!SWIG_IsOK(ecode4)) {
20849  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
20850  }
20851  arg4 = (PLFLT)(val4);
20852  plsdiplt(arg1,arg2,arg3,arg4);
20853  _outv = octave_value();
20854  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20855 fail:
20856  return _out;
20857 }
20858 
20859 
20860 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
20861  PLFLT arg1 ;
20862  PLFLT arg2 ;
20863  PLFLT arg3 ;
20864  PLFLT arg4 ;
20865  double val1 ;
20866  int ecode1 = 0 ;
20867  double val2 ;
20868  int ecode2 = 0 ;
20869  double val3 ;
20870  int ecode3 = 0 ;
20871  double val4 ;
20872  int ecode4 = 0 ;
20873  octave_value_list _out;
20874  octave_value_list *_outp=&_out;
20875  octave_value _outv;
20876 
20877  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
20878  SWIG_fail;
20879  }
20880  ecode1 = SWIG_AsVal_double(args(0), &val1);
20881  if (!SWIG_IsOK(ecode1)) {
20882  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
20883  }
20884  arg1 = (PLFLT)(val1);
20885  ecode2 = SWIG_AsVal_double(args(1), &val2);
20886  if (!SWIG_IsOK(ecode2)) {
20887  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
20888  }
20889  arg2 = (PLFLT)(val2);
20890  ecode3 = SWIG_AsVal_double(args(2), &val3);
20891  if (!SWIG_IsOK(ecode3)) {
20892  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
20893  }
20894  arg3 = (PLFLT)(val3);
20895  ecode4 = SWIG_AsVal_double(args(3), &val4);
20896  if (!SWIG_IsOK(ecode4)) {
20897  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
20898  }
20899  arg4 = (PLFLT)(val4);
20900  plsdiplz(arg1,arg2,arg3,arg4);
20901  _outv = octave_value();
20902  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20903 fail:
20904  return _out;
20905 }
20906 
20907 
20908 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
20909  unsigned int arg1 ;
20910  unsigned int val1 ;
20911  int ecode1 = 0 ;
20912  octave_value_list _out;
20913  octave_value_list *_outp=&_out;
20914  octave_value _outv;
20915 
20916  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
20917  SWIG_fail;
20918  }
20919  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
20920  if (!SWIG_IsOK(ecode1)) {
20921  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
20922  }
20923  arg1 = (unsigned int)(val1);
20924  plseed(arg1);
20925  _outv = octave_value();
20926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20927 fail:
20928  return _out;
20929 }
20930 
20931 
20932 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
20933  char arg1 ;
20934  char val1 ;
20935  int ecode1 = 0 ;
20936  octave_value_list _out;
20937  octave_value_list *_outp=&_out;
20938  octave_value _outv;
20939 
20940  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
20941  SWIG_fail;
20942  }
20943  ecode1 = SWIG_AsVal_char(args(0), &val1);
20944  if (!SWIG_IsOK(ecode1)) {
20945  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
20946  }
20947  arg1 = (char)(val1);
20948  plsesc(arg1);
20949  _outv = octave_value();
20950  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20951 fail:
20952  return _out;
20953 }
20954 
20955 
20956 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
20957  char *arg1 = (char *) 0 ;
20958  char *arg2 = (char *) 0 ;
20959  int res1 ;
20960  char *buf1 = 0 ;
20961  int alloc1 = 0 ;
20962  int res2 ;
20963  char *buf2 = 0 ;
20964  int alloc2 = 0 ;
20965  octave_value_list _out;
20966  octave_value_list *_outp=&_out;
20967  octave_value _outv;
20968  PLINT result;
20969 
20970  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
20971  SWIG_fail;
20972  }
20973  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20974  if (!SWIG_IsOK(res1)) {
20975  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
20976  }
20977  arg1 = (char *)(buf1);
20978  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20979  if (!SWIG_IsOK(res2)) {
20980  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
20981  }
20982  arg2 = (char *)(buf2);
20983  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
20984  _outv = SWIG_From_int((int)(result));
20985  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20986  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20987  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20988 fail:
20989  return _out;
20990 }
20991 
20992 
20993 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
20994  PLINT arg1 ;
20995  PLINT arg2 ;
20996  PLINT arg3 ;
20997  int val1 ;
20998  int ecode1 = 0 ;
20999  int val2 ;
21000  int ecode2 = 0 ;
21001  int val3 ;
21002  int ecode3 = 0 ;
21003  octave_value_list _out;
21004  octave_value_list *_outp=&_out;
21005  octave_value _outv;
21006 
21007  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
21008  SWIG_fail;
21009  }
21010  ecode1 = SWIG_AsVal_int(args(0), &val1);
21011  if (!SWIG_IsOK(ecode1)) {
21012  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
21013  }
21014  arg1 = (PLINT)(val1);
21015  ecode2 = SWIG_AsVal_int(args(1), &val2);
21016  if (!SWIG_IsOK(ecode2)) {
21017  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
21018  }
21019  arg2 = (PLINT)(val2);
21020  ecode3 = SWIG_AsVal_int(args(2), &val3);
21021  if (!SWIG_IsOK(ecode3)) {
21022  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
21023  }
21024  arg3 = (PLINT)(val3);
21025  plsfam(arg1,arg2,arg3);
21026  _outv = octave_value();
21027  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21028 fail:
21029  return _out;
21030 }
21031 
21032 
21033 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
21034  PLUNICODE arg1 ;
21035  unsigned int val1 ;
21036  int ecode1 = 0 ;
21037  octave_value_list _out;
21038  octave_value_list *_outp=&_out;
21039  octave_value _outv;
21040 
21041  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
21042  SWIG_fail;
21043  }
21044  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
21045  if (!SWIG_IsOK(ecode1)) {
21046  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
21047  }
21048  arg1 = (PLUNICODE)(val1);
21049  plsfci(arg1);
21050  _outv = octave_value();
21051  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21052 fail:
21053  return _out;
21054 }
21055 
21056 
21057 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
21058  char *arg1 = (char *) 0 ;
21059  int res1 ;
21060  char *buf1 = 0 ;
21061  int alloc1 = 0 ;
21062  octave_value_list _out;
21063  octave_value_list *_outp=&_out;
21064  octave_value _outv;
21065 
21066  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
21067  SWIG_fail;
21068  }
21069  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21070  if (!SWIG_IsOK(res1)) {
21071  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
21072  }
21073  arg1 = (char *)(buf1);
21074  plsfnam((char const *)arg1);
21075  _outv = octave_value();
21076  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21077  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21078 fail:
21079  return _out;
21080 }
21081 
21082 
21083 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
21084  PLINT arg1 ;
21085  PLINT arg2 ;
21086  PLINT arg3 ;
21087  int val1 ;
21088  int ecode1 = 0 ;
21089  int val2 ;
21090  int ecode2 = 0 ;
21091  int val3 ;
21092  int ecode3 = 0 ;
21093  octave_value_list _out;
21094  octave_value_list *_outp=&_out;
21095  octave_value _outv;
21096 
21097  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
21098  SWIG_fail;
21099  }
21100  ecode1 = SWIG_AsVal_int(args(0), &val1);
21101  if (!SWIG_IsOK(ecode1)) {
21102  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
21103  }
21104  arg1 = (PLINT)(val1);
21105  ecode2 = SWIG_AsVal_int(args(1), &val2);
21106  if (!SWIG_IsOK(ecode2)) {
21107  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
21108  }
21109  arg2 = (PLINT)(val2);
21110  ecode3 = SWIG_AsVal_int(args(2), &val3);
21111  if (!SWIG_IsOK(ecode3)) {
21112  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
21113  }
21114  arg3 = (PLINT)(val3);
21115  plsfont(arg1,arg2,arg3);
21116  _outv = octave_value();
21117  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21118 fail:
21119  return _out;
21120 }
21121 
21122 
21123 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
21124  label_func arg1 = (label_func) 0 ;
21125  PLPointer arg2 = (PLPointer) 0 ;
21126  int res2 ;
21127  octave_value_list _out;
21128  octave_value_list *_outp=&_out;
21129  octave_value _outv;
21130 
21131  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
21132  SWIG_fail;
21133  }
21134  {
21135  octave_value obj = args(0);
21136  if ( !obj.is_empty() )
21137  {
21138  if ( obj.is_function_handle() || obj.is_inline_function() )
21139  {
21140  fcnLabelFunc = obj.function_value();
21141  }
21142  else if ( obj.is_string() )
21143  {
21144  nameLabelFunc = obj.string_value();
21145  fcnLabelFunc = NULL;
21146  }
21147  arg1 = labelfunc_octave;
21148  }
21149  else
21150  {
21151  arg1 = NULL;
21152  }
21153  }
21154  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
21155  if (!SWIG_IsOK(res2)) {
21156  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
21157  }
21158  plslabelfunc(arg1,arg2);
21159  _outv = octave_value();
21160  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21161 fail:
21162  return _out;
21163 }
21164 
21165 
21166 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
21167  PLFLT arg1 ;
21168  PLFLT arg2 ;
21169  double val1 ;
21170  int ecode1 = 0 ;
21171  double val2 ;
21172  int ecode2 = 0 ;
21173  octave_value_list _out;
21174  octave_value_list *_outp=&_out;
21175  octave_value _outv;
21176 
21177  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
21178  SWIG_fail;
21179  }
21180  ecode1 = SWIG_AsVal_double(args(0), &val1);
21181  if (!SWIG_IsOK(ecode1)) {
21182  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
21183  }
21184  arg1 = (PLFLT)(val1);
21185  ecode2 = SWIG_AsVal_double(args(1), &val2);
21186  if (!SWIG_IsOK(ecode2)) {
21187  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
21188  }
21189  arg2 = (PLFLT)(val2);
21190  plsmaj(arg1,arg2);
21191  _outv = octave_value();
21192  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21193 fail:
21194  return _out;
21195 }
21196 
21197 
21198 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
21199  PLFLT arg1 ;
21200  PLFLT arg2 ;
21201  double val1 ;
21202  int ecode1 = 0 ;
21203  double val2 ;
21204  int ecode2 = 0 ;
21205  octave_value_list _out;
21206  octave_value_list *_outp=&_out;
21207  octave_value _outv;
21208 
21209  if (!SWIG_check_num_args("plsmin",args.length(),2,2,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 '" "plsmin" "', 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 '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
21220  }
21221  arg2 = (PLFLT)(val2);
21222  plsmin(arg1,arg2);
21223  _outv = octave_value();
21224  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21225 fail:
21226  return _out;
21227 }
21228 
21229 
21230 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
21231  PLINT arg1 ;
21232  int val1 ;
21233  int ecode1 = 0 ;
21234  octave_value_list _out;
21235  octave_value_list *_outp=&_out;
21236  octave_value _outv;
21237 
21238  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
21239  SWIG_fail;
21240  }
21241  ecode1 = SWIG_AsVal_int(args(0), &val1);
21242  if (!SWIG_IsOK(ecode1)) {
21243  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
21244  }
21245  arg1 = (PLINT)(val1);
21246  plsori(arg1);
21247  _outv = octave_value();
21248  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21249 fail:
21250  return _out;
21251 }
21252 
21253 
21254 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
21255  PLFLT arg1 ;
21256  PLFLT arg2 ;
21257  PLINT arg3 ;
21258  PLINT arg4 ;
21259  PLINT arg5 ;
21260  PLINT arg6 ;
21261  double val1 ;
21262  int ecode1 = 0 ;
21263  double val2 ;
21264  int ecode2 = 0 ;
21265  int val3 ;
21266  int ecode3 = 0 ;
21267  int val4 ;
21268  int ecode4 = 0 ;
21269  int val5 ;
21270  int ecode5 = 0 ;
21271  int val6 ;
21272  int ecode6 = 0 ;
21273  octave_value_list _out;
21274  octave_value_list *_outp=&_out;
21275  octave_value _outv;
21276 
21277  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
21278  SWIG_fail;
21279  }
21280  ecode1 = SWIG_AsVal_double(args(0), &val1);
21281  if (!SWIG_IsOK(ecode1)) {
21282  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
21283  }
21284  arg1 = (PLFLT)(val1);
21285  ecode2 = SWIG_AsVal_double(args(1), &val2);
21286  if (!SWIG_IsOK(ecode2)) {
21287  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
21288  }
21289  arg2 = (PLFLT)(val2);
21290  ecode3 = SWIG_AsVal_int(args(2), &val3);
21291  if (!SWIG_IsOK(ecode3)) {
21292  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
21293  }
21294  arg3 = (PLINT)(val3);
21295  ecode4 = SWIG_AsVal_int(args(3), &val4);
21296  if (!SWIG_IsOK(ecode4)) {
21297  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
21298  }
21299  arg4 = (PLINT)(val4);
21300  ecode5 = SWIG_AsVal_int(args(4), &val5);
21301  if (!SWIG_IsOK(ecode5)) {
21302  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
21303  }
21304  arg5 = (PLINT)(val5);
21305  ecode6 = SWIG_AsVal_int(args(5), &val6);
21306  if (!SWIG_IsOK(ecode6)) {
21307  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
21308  }
21309  arg6 = (PLINT)(val6);
21310  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
21311  _outv = octave_value();
21312  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21313 fail:
21314  return _out;
21315 }
21316 
21317 
21318 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
21319  char *arg1 = (char *) 0 ;
21320  int res1 ;
21321  char *buf1 = 0 ;
21322  int alloc1 = 0 ;
21323  octave_value_list _out;
21324  octave_value_list *_outp=&_out;
21325  octave_value _outv;
21326 
21327  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
21328  SWIG_fail;
21329  }
21330  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21331  if (!SWIG_IsOK(res1)) {
21332  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
21333  }
21334  arg1 = (char *)(buf1);
21335  plspal0((char const *)arg1);
21336  _outv = octave_value();
21337  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21338  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21339 fail:
21340  return _out;
21341 }
21342 
21343 
21344 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
21345  char *arg1 = (char *) 0 ;
21346  PLBOOL arg2 ;
21347  int res1 ;
21348  char *buf1 = 0 ;
21349  int alloc1 = 0 ;
21350  int val2 ;
21351  int ecode2 = 0 ;
21352  octave_value_list _out;
21353  octave_value_list *_outp=&_out;
21354  octave_value _outv;
21355 
21356  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
21357  SWIG_fail;
21358  }
21359  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21360  if (!SWIG_IsOK(res1)) {
21361  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
21362  }
21363  arg1 = (char *)(buf1);
21364  ecode2 = SWIG_AsVal_int(args(1), &val2);
21365  if (!SWIG_IsOK(ecode2)) {
21366  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
21367  }
21368  arg2 = (PLBOOL)(val2);
21369  plspal1((char const *)arg1,arg2);
21370  _outv = octave_value();
21371  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21372  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21373 fail:
21374  return _out;
21375 }
21376 
21377 
21378 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
21379  PLBOOL arg1 ;
21380  int val1 ;
21381  int ecode1 = 0 ;
21382  octave_value_list _out;
21383  octave_value_list *_outp=&_out;
21384  octave_value _outv;
21385 
21386  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
21387  SWIG_fail;
21388  }
21389  ecode1 = SWIG_AsVal_int(args(0), &val1);
21390  if (!SWIG_IsOK(ecode1)) {
21391  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
21392  }
21393  arg1 = (PLBOOL)(val1);
21394  plspause(arg1);
21395  _outv = octave_value();
21396  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21397 fail:
21398  return _out;
21399 }
21400 
21401 
21402 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
21403  PLINT arg1 ;
21404  int val1 ;
21405  int ecode1 = 0 ;
21406  octave_value_list _out;
21407  octave_value_list *_outp=&_out;
21408  octave_value _outv;
21409 
21410  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
21411  SWIG_fail;
21412  }
21413  ecode1 = SWIG_AsVal_int(args(0), &val1);
21414  if (!SWIG_IsOK(ecode1)) {
21415  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
21416  }
21417  arg1 = (PLINT)(val1);
21418  plsstrm(arg1);
21419  _outv = octave_value();
21420  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21421 fail:
21422  return _out;
21423 }
21424 
21425 
21426 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
21427  PLINT arg1 ;
21428  PLINT arg2 ;
21429  int val1 ;
21430  int ecode1 = 0 ;
21431  int val2 ;
21432  int ecode2 = 0 ;
21433  octave_value_list _out;
21434  octave_value_list *_outp=&_out;
21435  octave_value _outv;
21436 
21437  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
21438  SWIG_fail;
21439  }
21440  ecode1 = SWIG_AsVal_int(args(0), &val1);
21441  if (!SWIG_IsOK(ecode1)) {
21442  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
21443  }
21444  arg1 = (PLINT)(val1);
21445  ecode2 = SWIG_AsVal_int(args(1), &val2);
21446  if (!SWIG_IsOK(ecode2)) {
21447  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
21448  }
21449  arg2 = (PLINT)(val2);
21450  plssub(arg1,arg2);
21451  _outv = octave_value();
21452  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21453 fail:
21454  return _out;
21455 }
21456 
21457 
21458 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
21459  PLFLT arg1 ;
21460  PLFLT arg2 ;
21461  double val1 ;
21462  int ecode1 = 0 ;
21463  double val2 ;
21464  int ecode2 = 0 ;
21465  octave_value_list _out;
21466  octave_value_list *_outp=&_out;
21467  octave_value _outv;
21468 
21469  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
21470  SWIG_fail;
21471  }
21472  ecode1 = SWIG_AsVal_double(args(0), &val1);
21473  if (!SWIG_IsOK(ecode1)) {
21474  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
21475  }
21476  arg1 = (PLFLT)(val1);
21477  ecode2 = SWIG_AsVal_double(args(1), &val2);
21478  if (!SWIG_IsOK(ecode2)) {
21479  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
21480  }
21481  arg2 = (PLFLT)(val2);
21482  plssym(arg1,arg2);
21483  _outv = octave_value();
21484  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21485 fail:
21486  return _out;
21487 }
21488 
21489 
21490 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
21491  PLINT arg1 ;
21492  PLINT arg2 ;
21493  int val1 ;
21494  int ecode1 = 0 ;
21495  int val2 ;
21496  int ecode2 = 0 ;
21497  octave_value_list _out;
21498  octave_value_list *_outp=&_out;
21499  octave_value _outv;
21500 
21501  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
21502  SWIG_fail;
21503  }
21504  ecode1 = SWIG_AsVal_int(args(0), &val1);
21505  if (!SWIG_IsOK(ecode1)) {
21506  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
21507  }
21508  arg1 = (PLINT)(val1);
21509  ecode2 = SWIG_AsVal_int(args(1), &val2);
21510  if (!SWIG_IsOK(ecode2)) {
21511  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
21512  }
21513  arg2 = (PLINT)(val2);
21514  plstar(arg1,arg2);
21515  _outv = octave_value();
21516  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21517 fail:
21518  return _out;
21519 }
21520 
21521 
21522 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
21523  char *arg1 = (char *) 0 ;
21524  PLINT arg2 ;
21525  PLINT arg3 ;
21526  int res1 ;
21527  char *buf1 = 0 ;
21528  int alloc1 = 0 ;
21529  int val2 ;
21530  int ecode2 = 0 ;
21531  int val3 ;
21532  int ecode3 = 0 ;
21533  octave_value_list _out;
21534  octave_value_list *_outp=&_out;
21535  octave_value _outv;
21536 
21537  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
21538  SWIG_fail;
21539  }
21540  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21541  if (!SWIG_IsOK(res1)) {
21542  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
21543  }
21544  arg1 = (char *)(buf1);
21545  ecode2 = SWIG_AsVal_int(args(1), &val2);
21546  if (!SWIG_IsOK(ecode2)) {
21547  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
21548  }
21549  arg2 = (PLINT)(val2);
21550  ecode3 = SWIG_AsVal_int(args(2), &val3);
21551  if (!SWIG_IsOK(ecode3)) {
21552  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
21553  }
21554  arg3 = (PLINT)(val3);
21555  plstart((char const *)arg1,arg2,arg3);
21556  _outv = octave_value();
21557  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21558  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21559 fail:
21560  return _out;
21561 }
21562 
21563 
21564 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
21565  ct_func arg1 = (ct_func) 0 ;
21566  PLPointer arg2 = (PLPointer) 0 ;
21567  int res2 ;
21568  octave_value_list _out;
21569  octave_value_list *_outp=&_out;
21570  octave_value _outv;
21571 
21572  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
21573  SWIG_fail;
21574  }
21575  {
21576  octave_value obj = args(0);
21577  if ( !obj.is_empty() )
21578  {
21579  if ( obj.is_function_handle() || obj.is_inline_function() )
21580  {
21581  fcnCoordTrans = obj.function_value();
21582  }
21583  else if ( obj.is_string() )
21584  {
21585  nameCoordTrans = obj.string_value();
21586  fcnCoordTrans = NULL;
21587  }
21588  arg1 = ct_octave;
21589  }
21590  else
21591  {
21592  arg1 = NULL;
21593  }
21594  }
21595  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
21596  if (!SWIG_IsOK(res2)) {
21597  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
21598  }
21599  plstransform(arg1,arg2);
21600  _outv = octave_value();
21601  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21602 fail:
21603  return _out;
21604 }
21605 
21606 
21607 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
21608  PLINT arg1 ;
21609  PLFLT *arg2 = (PLFLT *) 0 ;
21610  PLFLT *arg3 = (PLFLT *) 0 ;
21611  char *arg4 = (char *) 0 ;
21612  Matrix temp1 ;
21613  Matrix temp3 ;
21614  int res4 ;
21615  char *buf4 = 0 ;
21616  int alloc4 = 0 ;
21617  octave_value_list _out;
21618  octave_value_list *_outp=&_out;
21619  octave_value _outv;
21620 
21621  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
21622  SWIG_fail;
21623  }
21624  {
21625  if ( _n_dims( args(0) ) > 1 )
21626  {
21627  error( "argument must be a scalar or vector" ); SWIG_fail;
21628  }
21629  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21630  temp1 = args(0).matrix_value();
21631  arg2 = &temp1( 0, 0 );
21632  }
21633  {
21634  if ( _n_dims( args(1) ) > 1 )
21635  {
21636  error( "argument must be a scalar or vector" ); SWIG_fail;
21637  }
21638  if ( _dim( args(1), 0 ) != Alen )
21639  {
21640  error( "argument vectors must be same length" ); SWIG_fail;
21641  }
21642  temp3 = args(1).matrix_value();
21643  arg3 = &temp3( 0, 0 );
21644  }
21645  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
21646  if (!SWIG_IsOK(res4)) {
21647  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
21648  }
21649  arg4 = (char *)(buf4);
21650  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
21651  _outv = octave_value();
21652  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21653  {
21654 
21655  }
21656  {
21657 
21658  }
21659  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
21660 fail:
21661  return _out;
21662 }
21663 
21664 
21665 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
21666  PLINT arg1 ;
21667  PLFLT *arg2 = (PLFLT *) 0 ;
21668  PLFLT *arg3 = (PLFLT *) 0 ;
21669  PLFLT *arg4 = (PLFLT *) 0 ;
21670  char *arg5 = (char *) 0 ;
21671  Matrix temp1 ;
21672  Matrix temp3 ;
21673  Matrix temp4 ;
21674  int res5 ;
21675  char *buf5 = 0 ;
21676  int alloc5 = 0 ;
21677  octave_value_list _out;
21678  octave_value_list *_outp=&_out;
21679  octave_value _outv;
21680 
21681  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
21682  SWIG_fail;
21683  }
21684  {
21685  if ( _n_dims( args(0) ) > 1 )
21686  {
21687  error( "argument must be a scalar or vector" ); SWIG_fail;
21688  }
21689  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21690  temp1 = args(0).matrix_value();
21691  arg2 = &temp1( 0, 0 );
21692  }
21693  {
21694  if ( _n_dims( args(1) ) > 1 )
21695  {
21696  error( "argument must be a scalar or vector" ); SWIG_fail;
21697  }
21698  if ( _dim( args(1), 0 ) != Alen )
21699  {
21700  error( "argument vectors must be same length" ); SWIG_fail;
21701  }
21702  temp3 = args(1).matrix_value();
21703  arg3 = &temp3( 0, 0 );
21704  }
21705  {
21706  if ( _n_dims( args(2) ) > 1 )
21707  {
21708  error( "argument must be a scalar or vector" ); SWIG_fail;
21709  }
21710  if ( _dim( args(2), 0 ) != Alen )
21711  {
21712  error( "argument vectors must be same length" ); SWIG_fail;
21713  }
21714  temp4 = args(2).matrix_value();
21715  arg4 = &temp4( 0, 0 );
21716  }
21717  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
21718  if (!SWIG_IsOK(res5)) {
21719  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
21720  }
21721  arg5 = (char *)(buf5);
21722  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
21723  _outv = octave_value();
21724  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21725  {
21726 
21727  }
21728  {
21729 
21730  }
21731  {
21732 
21733  }
21734  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21735 fail:
21736  return _out;
21737 }
21738 
21739 
21740 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
21741  PLINT arg1 ;
21742  PLINT arg2 ;
21743  PLFLT arg3 ;
21744  PLFLT arg4 ;
21745  int val1 ;
21746  int ecode1 = 0 ;
21747  int val2 ;
21748  int ecode2 = 0 ;
21749  double val3 ;
21750  int ecode3 = 0 ;
21751  double val4 ;
21752  int ecode4 = 0 ;
21753  octave_value_list _out;
21754  octave_value_list *_outp=&_out;
21755  octave_value _outv;
21756 
21757  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
21758  SWIG_fail;
21759  }
21760  ecode1 = SWIG_AsVal_int(args(0), &val1);
21761  if (!SWIG_IsOK(ecode1)) {
21762  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
21763  }
21764  arg1 = (PLINT)(val1);
21765  ecode2 = SWIG_AsVal_int(args(1), &val2);
21766  if (!SWIG_IsOK(ecode2)) {
21767  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
21768  }
21769  arg2 = (PLINT)(val2);
21770  ecode3 = SWIG_AsVal_double(args(2), &val3);
21771  if (!SWIG_IsOK(ecode3)) {
21772  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
21773  }
21774  arg3 = (PLFLT)(val3);
21775  ecode4 = SWIG_AsVal_double(args(3), &val4);
21776  if (!SWIG_IsOK(ecode4)) {
21777  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
21778  }
21779  arg4 = (PLFLT)(val4);
21780  plstripa(arg1,arg2,arg3,arg4);
21781  _outv = octave_value();
21782  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21783 fail:
21784  return _out;
21785 }
21786 
21787 
21788 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
21789  PLINT arg1 ;
21790  int val1 ;
21791  int ecode1 = 0 ;
21792  octave_value_list _out;
21793  octave_value_list *_outp=&_out;
21794  octave_value _outv;
21795 
21796  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
21797  SWIG_fail;
21798  }
21799  ecode1 = SWIG_AsVal_int(args(0), &val1);
21800  if (!SWIG_IsOK(ecode1)) {
21801  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
21802  }
21803  arg1 = (PLINT)(val1);
21804  plstripd(arg1);
21805  _outv = octave_value();
21806  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21807 fail:
21808  return _out;
21809 }
21810 
21811 
21812 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
21813  PLINT arg1 ;
21814  PLINT *arg2 = (PLINT *) 0 ;
21815  PLINT *arg3 = (PLINT *) 0 ;
21816  Matrix temp1 ;
21817  Matrix temp3 ;
21818  octave_value_list _out;
21819  octave_value_list *_outp=&_out;
21820  octave_value _outv;
21821 
21822  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
21823  SWIG_fail;
21824  }
21825  {
21826  if ( _n_dims( args(0) ) > 1 )
21827  {
21828  error( "argument must be a scalar or vector" ); SWIG_fail;
21829  }
21830  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21831  arg2 = new PLINT[Alen];
21832  temp1 = args(0).matrix_value();
21833  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21834  }
21835  {
21836  if ( _n_dims( args(1) ) > 1 )
21837  {
21838  error( "argument must be a scalar or vector" ); SWIG_fail;
21839  }
21840  if ( _dim( args(1), 0 ) != Alen )
21841  {
21842  error( "argument vectors must be same length" ); SWIG_fail;
21843  }
21844  temp3 = args(1).matrix_value();
21845  arg3 = new PLINT[Alen];
21846  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21847  }
21848  plstyl(arg1,(int const *)arg2,(int const *)arg3);
21849  _outv = octave_value();
21850  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21851  {
21852  delete [] arg2;
21853  }
21854  {
21855  delete [] arg3;
21856  }
21857 fail:
21858  return _out;
21859 }
21860 
21861 
21862 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
21863  PLFLT *arg1 = (PLFLT *) 0 ;
21864  PLFLT *arg2 = (PLFLT *) 0 ;
21865  PLINT arg3 ;
21866  PLBOOL arg4 ;
21867  Matrix temp1 ;
21868  Matrix temp2 ;
21869  int val4 ;
21870  int ecode4 = 0 ;
21871  octave_value_list _out;
21872  octave_value_list *_outp=&_out;
21873  octave_value _outv;
21874 
21875  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
21876  SWIG_fail;
21877  }
21878  {
21879  if ( _n_dims( args(0) ) > 1 )
21880  {
21881  error( "argument must be a scalar or vector" ); SWIG_fail;
21882  }
21883  if ( !args(0).is_empty() )
21884  {
21885  Alen = (PLINT) ( _dim( args(0), 0 ) );
21886  temp1 = args(0).matrix_value();
21887  arg1 = &temp1( 0, 0 );
21888  }
21889  else
21890  {
21891  arg1 = NULL;
21892  Alen = 0;
21893  }
21894  }
21895  {
21896  if ( _n_dims( args(1) ) > 1 )
21897  {
21898  error( "argument must be a scalar or vector" ); SWIG_fail;
21899  }
21900  if ( !args(1).is_empty() )
21901  {
21902  if ( _dim( args(1), 0 ) != Alen )
21903  {
21904  error( "argument vectors must be same length" ); SWIG_fail;
21905  }
21906  temp2 = args(1).matrix_value();
21907  arg2 = &temp2( 0, 0 );
21908  arg3 = (PLINT) ( _dim( args(1), 0 ) );
21909  }
21910  else
21911  {
21912  arg2 = NULL;
21913  arg3 = 0;
21914  }
21915  }
21916  ecode4 = SWIG_AsVal_int(args(2), &val4);
21917  if (!SWIG_IsOK(ecode4)) {
21918  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
21919  }
21920  arg4 = (PLBOOL)(val4);
21921  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
21922  _outv = octave_value();
21923  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21924  {
21925 
21926  }
21927  {
21928 
21929  }
21930 fail:
21931  return _out;
21932 }
21933 
21934 
21935 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
21936  PLFLT arg1 ;
21937  PLFLT arg2 ;
21938  PLFLT arg3 ;
21939  PLFLT arg4 ;
21940  double val1 ;
21941  int ecode1 = 0 ;
21942  double val2 ;
21943  int ecode2 = 0 ;
21944  double val3 ;
21945  int ecode3 = 0 ;
21946  double val4 ;
21947  int ecode4 = 0 ;
21948  octave_value_list _out;
21949  octave_value_list *_outp=&_out;
21950  octave_value _outv;
21951 
21952  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
21953  SWIG_fail;
21954  }
21955  ecode1 = SWIG_AsVal_double(args(0), &val1);
21956  if (!SWIG_IsOK(ecode1)) {
21957  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
21958  }
21959  arg1 = (PLFLT)(val1);
21960  ecode2 = SWIG_AsVal_double(args(1), &val2);
21961  if (!SWIG_IsOK(ecode2)) {
21962  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
21963  }
21964  arg2 = (PLFLT)(val2);
21965  ecode3 = SWIG_AsVal_double(args(2), &val3);
21966  if (!SWIG_IsOK(ecode3)) {
21967  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
21968  }
21969  arg3 = (PLFLT)(val3);
21970  ecode4 = SWIG_AsVal_double(args(3), &val4);
21971  if (!SWIG_IsOK(ecode4)) {
21972  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
21973  }
21974  arg4 = (PLFLT)(val4);
21975  plsvpa(arg1,arg2,arg3,arg4);
21976  _outv = octave_value();
21977  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21978 fail:
21979  return _out;
21980 }
21981 
21982 
21983 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
21984  PLINT arg1 ;
21985  PLINT arg2 ;
21986  int val1 ;
21987  int ecode1 = 0 ;
21988  int val2 ;
21989  int ecode2 = 0 ;
21990  octave_value_list _out;
21991  octave_value_list *_outp=&_out;
21992  octave_value _outv;
21993 
21994  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
21995  SWIG_fail;
21996  }
21997  ecode1 = SWIG_AsVal_int(args(0), &val1);
21998  if (!SWIG_IsOK(ecode1)) {
21999  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
22000  }
22001  arg1 = (PLINT)(val1);
22002  ecode2 = SWIG_AsVal_int(args(1), &val2);
22003  if (!SWIG_IsOK(ecode2)) {
22004  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
22005  }
22006  arg2 = (PLINT)(val2);
22007  plsxax(arg1,arg2);
22008  _outv = octave_value();
22009  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22010 fail:
22011  return _out;
22012 }
22013 
22014 
22015 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
22016  PLINT arg1 ;
22017  PLINT arg2 ;
22018  int val1 ;
22019  int ecode1 = 0 ;
22020  int val2 ;
22021  int ecode2 = 0 ;
22022  octave_value_list _out;
22023  octave_value_list *_outp=&_out;
22024  octave_value _outv;
22025 
22026  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
22027  SWIG_fail;
22028  }
22029  ecode1 = SWIG_AsVal_int(args(0), &val1);
22030  if (!SWIG_IsOK(ecode1)) {
22031  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
22032  }
22033  arg1 = (PLINT)(val1);
22034  ecode2 = SWIG_AsVal_int(args(1), &val2);
22035  if (!SWIG_IsOK(ecode2)) {
22036  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
22037  }
22038  arg2 = (PLINT)(val2);
22039  plsyax(arg1,arg2);
22040  _outv = octave_value();
22041  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22042 fail:
22043  return _out;
22044 }
22045 
22046 
22047 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
22048  PLINT arg1 ;
22049  PLFLT *arg2 = (PLFLT *) 0 ;
22050  PLFLT *arg3 = (PLFLT *) 0 ;
22051  PLINT arg4 ;
22052  Matrix temp1 ;
22053  Matrix temp3 ;
22054  int val4 ;
22055  int ecode4 = 0 ;
22056  octave_value_list _out;
22057  octave_value_list *_outp=&_out;
22058  octave_value _outv;
22059 
22060  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
22061  SWIG_fail;
22062  }
22063  {
22064  if ( _n_dims( args(0) ) > 1 )
22065  {
22066  error( "argument must be a scalar or vector" ); SWIG_fail;
22067  }
22068  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22069  temp1 = args(0).matrix_value();
22070  arg2 = &temp1( 0, 0 );
22071  }
22072  {
22073  if ( _n_dims( args(1) ) > 1 )
22074  {
22075  error( "argument must be a scalar or vector" ); SWIG_fail;
22076  }
22077  if ( _dim( args(1), 0 ) != Alen )
22078  {
22079  error( "argument vectors must be same length" ); SWIG_fail;
22080  }
22081  temp3 = args(1).matrix_value();
22082  arg3 = &temp3( 0, 0 );
22083  }
22084  ecode4 = SWIG_AsVal_int(args(2), &val4);
22085  if (!SWIG_IsOK(ecode4)) {
22086  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
22087  }
22088  arg4 = (PLINT)(val4);
22089  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
22090  _outv = octave_value();
22091  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22092  {
22093 
22094  }
22095  {
22096 
22097  }
22098 fail:
22099  return _out;
22100 }
22101 
22102 
22103 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
22104  PLINT arg1 ;
22105  PLINT arg2 ;
22106  int val1 ;
22107  int ecode1 = 0 ;
22108  int val2 ;
22109  int ecode2 = 0 ;
22110  octave_value_list _out;
22111  octave_value_list *_outp=&_out;
22112  octave_value _outv;
22113 
22114  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
22115  SWIG_fail;
22116  }
22117  ecode1 = SWIG_AsVal_int(args(0), &val1);
22118  if (!SWIG_IsOK(ecode1)) {
22119  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
22120  }
22121  arg1 = (PLINT)(val1);
22122  ecode2 = SWIG_AsVal_int(args(1), &val2);
22123  if (!SWIG_IsOK(ecode2)) {
22124  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
22125  }
22126  arg2 = (PLINT)(val2);
22127  plszax(arg1,arg2);
22128  _outv = octave_value();
22129  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22130 fail:
22131  return _out;
22132 }
22133 
22134 
22135 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
22136  octave_value_list _out;
22137  octave_value_list *_outp=&_out;
22138  octave_value _outv;
22139 
22140  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
22141  SWIG_fail;
22142  }
22143  pltext();
22144  _outv = octave_value();
22145  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22146 fail:
22147  return _out;
22148 }
22149 
22150 
22151 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
22152  char *arg1 = (char *) 0 ;
22153  int res1 ;
22154  char *buf1 = 0 ;
22155  int alloc1 = 0 ;
22156  octave_value_list _out;
22157  octave_value_list *_outp=&_out;
22158  octave_value _outv;
22159 
22160  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
22161  SWIG_fail;
22162  }
22163  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22164  if (!SWIG_IsOK(res1)) {
22165  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
22166  }
22167  arg1 = (char *)(buf1);
22168  pltimefmt((char const *)arg1);
22169  _outv = octave_value();
22170  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22171  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22172 fail:
22173  return _out;
22174 }
22175 
22176 
22177 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
22178  PLFLT arg1 ;
22179  double val1 ;
22180  int ecode1 = 0 ;
22181  octave_value_list _out;
22182  octave_value_list *_outp=&_out;
22183  octave_value _outv;
22184 
22185  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
22186  SWIG_fail;
22187  }
22188  ecode1 = SWIG_AsVal_double(args(0), &val1);
22189  if (!SWIG_IsOK(ecode1)) {
22190  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
22191  }
22192  arg1 = (PLFLT)(val1);
22193  plvasp(arg1);
22194  _outv = octave_value();
22195  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22196 fail:
22197  return _out;
22198 }
22199 
22200 
22201 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
22202  PLFLT arg1 ;
22203  PLFLT arg2 ;
22204  PLFLT arg3 ;
22205  PLFLT arg4 ;
22206  PLFLT arg5 ;
22207  double val1 ;
22208  int ecode1 = 0 ;
22209  double val2 ;
22210  int ecode2 = 0 ;
22211  double val3 ;
22212  int ecode3 = 0 ;
22213  double val4 ;
22214  int ecode4 = 0 ;
22215  double val5 ;
22216  int ecode5 = 0 ;
22217  octave_value_list _out;
22218  octave_value_list *_outp=&_out;
22219  octave_value _outv;
22220 
22221  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
22222  SWIG_fail;
22223  }
22224  ecode1 = SWIG_AsVal_double(args(0), &val1);
22225  if (!SWIG_IsOK(ecode1)) {
22226  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
22227  }
22228  arg1 = (PLFLT)(val1);
22229  ecode2 = SWIG_AsVal_double(args(1), &val2);
22230  if (!SWIG_IsOK(ecode2)) {
22231  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
22232  }
22233  arg2 = (PLFLT)(val2);
22234  ecode3 = SWIG_AsVal_double(args(2), &val3);
22235  if (!SWIG_IsOK(ecode3)) {
22236  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
22237  }
22238  arg3 = (PLFLT)(val3);
22239  ecode4 = SWIG_AsVal_double(args(3), &val4);
22240  if (!SWIG_IsOK(ecode4)) {
22241  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
22242  }
22243  arg4 = (PLFLT)(val4);
22244  ecode5 = SWIG_AsVal_double(args(4), &val5);
22245  if (!SWIG_IsOK(ecode5)) {
22246  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
22247  }
22248  arg5 = (PLFLT)(val5);
22249  plvpas(arg1,arg2,arg3,arg4,arg5);
22250  _outv = octave_value();
22251  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22252 fail:
22253  return _out;
22254 }
22255 
22256 
22257 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
22258  PLFLT arg1 ;
22259  PLFLT arg2 ;
22260  PLFLT arg3 ;
22261  PLFLT arg4 ;
22262  double val1 ;
22263  int ecode1 = 0 ;
22264  double val2 ;
22265  int ecode2 = 0 ;
22266  double val3 ;
22267  int ecode3 = 0 ;
22268  double val4 ;
22269  int ecode4 = 0 ;
22270  octave_value_list _out;
22271  octave_value_list *_outp=&_out;
22272  octave_value _outv;
22273 
22274  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
22275  SWIG_fail;
22276  }
22277  ecode1 = SWIG_AsVal_double(args(0), &val1);
22278  if (!SWIG_IsOK(ecode1)) {
22279  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
22280  }
22281  arg1 = (PLFLT)(val1);
22282  ecode2 = SWIG_AsVal_double(args(1), &val2);
22283  if (!SWIG_IsOK(ecode2)) {
22284  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
22285  }
22286  arg2 = (PLFLT)(val2);
22287  ecode3 = SWIG_AsVal_double(args(2), &val3);
22288  if (!SWIG_IsOK(ecode3)) {
22289  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
22290  }
22291  arg3 = (PLFLT)(val3);
22292  ecode4 = SWIG_AsVal_double(args(3), &val4);
22293  if (!SWIG_IsOK(ecode4)) {
22294  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
22295  }
22296  arg4 = (PLFLT)(val4);
22297  plvpor(arg1,arg2,arg3,arg4);
22298  _outv = octave_value();
22299  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22300 fail:
22301  return _out;
22302 }
22303 
22304 
22305 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
22306  octave_value_list _out;
22307  octave_value_list *_outp=&_out;
22308  octave_value _outv;
22309 
22310  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
22311  SWIG_fail;
22312  }
22313  plvsta();
22314  _outv = octave_value();
22315  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22316 fail:
22317  return _out;
22318 }
22319 
22320 
22321 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
22322  PLFLT arg1 ;
22323  PLFLT arg2 ;
22324  PLFLT arg3 ;
22325  PLFLT arg4 ;
22326  PLFLT arg5 ;
22327  PLFLT arg6 ;
22328  PLFLT arg7 ;
22329  PLFLT arg8 ;
22330  PLFLT arg9 ;
22331  PLFLT arg10 ;
22332  PLFLT arg11 ;
22333  double val1 ;
22334  int ecode1 = 0 ;
22335  double val2 ;
22336  int ecode2 = 0 ;
22337  double val3 ;
22338  int ecode3 = 0 ;
22339  double val4 ;
22340  int ecode4 = 0 ;
22341  double val5 ;
22342  int ecode5 = 0 ;
22343  double val6 ;
22344  int ecode6 = 0 ;
22345  double val7 ;
22346  int ecode7 = 0 ;
22347  double val8 ;
22348  int ecode8 = 0 ;
22349  double val9 ;
22350  int ecode9 = 0 ;
22351  double val10 ;
22352  int ecode10 = 0 ;
22353  double val11 ;
22354  int ecode11 = 0 ;
22355  octave_value_list _out;
22356  octave_value_list *_outp=&_out;
22357  octave_value _outv;
22358 
22359  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
22360  SWIG_fail;
22361  }
22362  ecode1 = SWIG_AsVal_double(args(0), &val1);
22363  if (!SWIG_IsOK(ecode1)) {
22364  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
22365  }
22366  arg1 = (PLFLT)(val1);
22367  ecode2 = SWIG_AsVal_double(args(1), &val2);
22368  if (!SWIG_IsOK(ecode2)) {
22369  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
22370  }
22371  arg2 = (PLFLT)(val2);
22372  ecode3 = SWIG_AsVal_double(args(2), &val3);
22373  if (!SWIG_IsOK(ecode3)) {
22374  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
22375  }
22376  arg3 = (PLFLT)(val3);
22377  ecode4 = SWIG_AsVal_double(args(3), &val4);
22378  if (!SWIG_IsOK(ecode4)) {
22379  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
22380  }
22381  arg4 = (PLFLT)(val4);
22382  ecode5 = SWIG_AsVal_double(args(4), &val5);
22383  if (!SWIG_IsOK(ecode5)) {
22384  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
22385  }
22386  arg5 = (PLFLT)(val5);
22387  ecode6 = SWIG_AsVal_double(args(5), &val6);
22388  if (!SWIG_IsOK(ecode6)) {
22389  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
22390  }
22391  arg6 = (PLFLT)(val6);
22392  ecode7 = SWIG_AsVal_double(args(6), &val7);
22393  if (!SWIG_IsOK(ecode7)) {
22394  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
22395  }
22396  arg7 = (PLFLT)(val7);
22397  ecode8 = SWIG_AsVal_double(args(7), &val8);
22398  if (!SWIG_IsOK(ecode8)) {
22399  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
22400  }
22401  arg8 = (PLFLT)(val8);
22402  ecode9 = SWIG_AsVal_double(args(8), &val9);
22403  if (!SWIG_IsOK(ecode9)) {
22404  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
22405  }
22406  arg9 = (PLFLT)(val9);
22407  ecode10 = SWIG_AsVal_double(args(9), &val10);
22408  if (!SWIG_IsOK(ecode10)) {
22409  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
22410  }
22411  arg10 = (PLFLT)(val10);
22412  ecode11 = SWIG_AsVal_double(args(10), &val11);
22413  if (!SWIG_IsOK(ecode11)) {
22414  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
22415  }
22416  arg11 = (PLFLT)(val11);
22417  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22418  _outv = octave_value();
22419  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22420 fail:
22421  return _out;
22422 }
22423 
22424 
22425 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
22426  PLFLT arg1 ;
22427  double val1 ;
22428  int ecode1 = 0 ;
22429  octave_value_list _out;
22430  octave_value_list *_outp=&_out;
22431  octave_value _outv;
22432 
22433  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
22434  SWIG_fail;
22435  }
22436  ecode1 = SWIG_AsVal_double(args(0), &val1);
22437  if (!SWIG_IsOK(ecode1)) {
22438  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
22439  }
22440  arg1 = (PLFLT)(val1);
22441  plwidth(arg1);
22442  _outv = octave_value();
22443  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22444 fail:
22445  return _out;
22446 }
22447 
22448 
22449 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
22450  PLFLT arg1 ;
22451  PLFLT arg2 ;
22452  PLFLT arg3 ;
22453  PLFLT arg4 ;
22454  double val1 ;
22455  int ecode1 = 0 ;
22456  double val2 ;
22457  int ecode2 = 0 ;
22458  double val3 ;
22459  int ecode3 = 0 ;
22460  double val4 ;
22461  int ecode4 = 0 ;
22462  octave_value_list _out;
22463  octave_value_list *_outp=&_out;
22464  octave_value _outv;
22465 
22466  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
22467  SWIG_fail;
22468  }
22469  ecode1 = SWIG_AsVal_double(args(0), &val1);
22470  if (!SWIG_IsOK(ecode1)) {
22471  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
22472  }
22473  arg1 = (PLFLT)(val1);
22474  ecode2 = SWIG_AsVal_double(args(1), &val2);
22475  if (!SWIG_IsOK(ecode2)) {
22476  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
22477  }
22478  arg2 = (PLFLT)(val2);
22479  ecode3 = SWIG_AsVal_double(args(2), &val3);
22480  if (!SWIG_IsOK(ecode3)) {
22481  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
22482  }
22483  arg3 = (PLFLT)(val3);
22484  ecode4 = SWIG_AsVal_double(args(3), &val4);
22485  if (!SWIG_IsOK(ecode4)) {
22486  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
22487  }
22488  arg4 = (PLFLT)(val4);
22489  plwind(arg1,arg2,arg3,arg4);
22490  _outv = octave_value();
22491  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22492 fail:
22493  return _out;
22494 }
22495 
22496 
22497 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
22498  PLBOOL arg1 ;
22499  PLBOOL *arg2 = (PLBOOL *) 0 ;
22500  int val1 ;
22501  int ecode1 = 0 ;
22502  PLBOOL temp2 ;
22503  int res2 = SWIG_TMPOBJ ;
22504  octave_value_list _out;
22505  octave_value_list *_outp=&_out;
22506  octave_value _outv;
22507 
22508  arg2 = &temp2;
22509  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
22510  SWIG_fail;
22511  }
22512  ecode1 = SWIG_AsVal_int(args(0), &val1);
22513  if (!SWIG_IsOK(ecode1)) {
22514  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
22515  }
22516  arg1 = (PLBOOL)(val1);
22517  plxormod(arg1,arg2);
22518  _outv = octave_value();
22519  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22520  if (SWIG_IsTmpObj(res2)) {
22521  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
22522  } else {
22523  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22524  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
22525  }
22526 fail:
22527  return _out;
22528 }
22529 
22530 
22531 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
22532  mapform_func arg1 = (mapform_func) 0 ;
22533  char *arg2 = (char *) 0 ;
22534  PLFLT arg3 ;
22535  PLFLT arg4 ;
22536  PLFLT arg5 ;
22537  PLFLT arg6 ;
22538  int res2 ;
22539  char *buf2 = 0 ;
22540  int alloc2 = 0 ;
22541  double val3 ;
22542  int ecode3 = 0 ;
22543  double val4 ;
22544  int ecode4 = 0 ;
22545  double val5 ;
22546  int ecode5 = 0 ;
22547  double val6 ;
22548  int ecode6 = 0 ;
22549  octave_value_list _out;
22550  octave_value_list *_outp=&_out;
22551  octave_value _outv;
22552 
22553  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
22554  SWIG_fail;
22555  }
22556  {
22557  octave_value obj = args(0);
22558  if ( !obj.is_empty() )
22559  {
22560  if ( obj.is_function_handle() || obj.is_inline_function() )
22561  {
22562  fcnMapForm = obj.function_value();
22563  }
22564  else if ( obj.is_string() )
22565  {
22566  nameMapForm = obj.string_value();
22567  fcnMapForm = NULL;
22568  }
22569  arg1 = mapform_octave;
22570  }
22571  else
22572  {
22573  arg1 = NULL;
22574  }
22575  }
22576  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22577  if (!SWIG_IsOK(res2)) {
22578  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
22579  }
22580  arg2 = (char *)(buf2);
22581  ecode3 = SWIG_AsVal_double(args(2), &val3);
22582  if (!SWIG_IsOK(ecode3)) {
22583  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
22584  }
22585  arg3 = (PLFLT)(val3);
22586  ecode4 = SWIG_AsVal_double(args(3), &val4);
22587  if (!SWIG_IsOK(ecode4)) {
22588  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
22589  }
22590  arg4 = (PLFLT)(val4);
22591  ecode5 = SWIG_AsVal_double(args(4), &val5);
22592  if (!SWIG_IsOK(ecode5)) {
22593  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
22594  }
22595  arg5 = (PLFLT)(val5);
22596  ecode6 = SWIG_AsVal_double(args(5), &val6);
22597  if (!SWIG_IsOK(ecode6)) {
22598  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
22599  }
22600  arg6 = (PLFLT)(val6);
22601  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
22602  _outv = octave_value();
22603  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22604  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22605 fail:
22606  return _out;
22607 }
22608 
22609 
22610 SWIG_DEFUN( plmapline, _wrap_plmapline, _wrap_plmapline_texinfo ) {
22611  mapform_func arg1 = (mapform_func) 0 ;
22612  char *arg2 = (char *) 0 ;
22613  PLFLT arg3 ;
22614  PLFLT arg4 ;
22615  PLFLT arg5 ;
22616  PLFLT arg6 ;
22617  PLINT *arg7 = (PLINT *) 0 ;
22618  PLINT arg8 ;
22619  int res2 ;
22620  char *buf2 = 0 ;
22621  int alloc2 = 0 ;
22622  double val3 ;
22623  int ecode3 = 0 ;
22624  double val4 ;
22625  int ecode4 = 0 ;
22626  double val5 ;
22627  int ecode5 = 0 ;
22628  double val6 ;
22629  int ecode6 = 0 ;
22630  Matrix temp7 ;
22631  octave_value_list _out;
22632  octave_value_list *_outp=&_out;
22633  octave_value _outv;
22634 
22635  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
22636  SWIG_fail;
22637  }
22638  {
22639  octave_value obj = args(0);
22640  if ( !obj.is_empty() )
22641  {
22642  if ( obj.is_function_handle() || obj.is_inline_function() )
22643  {
22644  fcnMapForm = obj.function_value();
22645  }
22646  else if ( obj.is_string() )
22647  {
22648  nameMapForm = obj.string_value();
22649  fcnMapForm = NULL;
22650  }
22651  arg1 = mapform_octave;
22652  }
22653  else
22654  {
22655  arg1 = NULL;
22656  }
22657  }
22658  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22659  if (!SWIG_IsOK(res2)) {
22660  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
22661  }
22662  arg2 = (char *)(buf2);
22663  ecode3 = SWIG_AsVal_double(args(2), &val3);
22664  if (!SWIG_IsOK(ecode3)) {
22665  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
22666  }
22667  arg3 = (PLFLT)(val3);
22668  ecode4 = SWIG_AsVal_double(args(3), &val4);
22669  if (!SWIG_IsOK(ecode4)) {
22670  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
22671  }
22672  arg4 = (PLFLT)(val4);
22673  ecode5 = SWIG_AsVal_double(args(4), &val5);
22674  if (!SWIG_IsOK(ecode5)) {
22675  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
22676  }
22677  arg5 = (PLFLT)(val5);
22678  ecode6 = SWIG_AsVal_double(args(5), &val6);
22679  if (!SWIG_IsOK(ecode6)) {
22680  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
22681  }
22682  arg6 = (PLFLT)(val6);
22683  {
22684  if ( _n_dims( args(6) ) > 1 )
22685  {
22686  error( "argument must be a scalar or vector" ); SWIG_fail;
22687  }
22688  if ( !args(6).is_empty() )
22689  {
22690  arg8 = (PLINT) ( _dim( args(6), 0 ) );
22691  temp7 = args(6).matrix_value();
22692  arg7 = new PLINT[arg8];
22693  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
22694  }
22695  else
22696  {
22697  arg7 = NULL;
22698  arg8 = 0;
22699  }
22700  }
22701  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
22702  _outv = octave_value();
22703  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22704  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22705  {
22706  delete [] arg7;
22707  }
22708 fail:
22709  return _out;
22710 }
22711 
22712 
22713 SWIG_DEFUN( plmapstring, _wrap_plmapstring, _wrap_plmapstring_texinfo ) {
22714  mapform_func arg1 = (mapform_func) 0 ;
22715  char *arg2 = (char *) 0 ;
22716  char *arg3 = (char *) 0 ;
22717  PLFLT arg4 ;
22718  PLFLT arg5 ;
22719  PLFLT arg6 ;
22720  PLFLT arg7 ;
22721  PLINT *arg8 = (PLINT *) 0 ;
22722  PLINT arg9 ;
22723  int res2 ;
22724  char *buf2 = 0 ;
22725  int alloc2 = 0 ;
22726  int res3 ;
22727  char *buf3 = 0 ;
22728  int alloc3 = 0 ;
22729  double val4 ;
22730  int ecode4 = 0 ;
22731  double val5 ;
22732  int ecode5 = 0 ;
22733  double val6 ;
22734  int ecode6 = 0 ;
22735  double val7 ;
22736  int ecode7 = 0 ;
22737  Matrix temp8 ;
22738  octave_value_list _out;
22739  octave_value_list *_outp=&_out;
22740  octave_value _outv;
22741 
22742  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
22743  SWIG_fail;
22744  }
22745  {
22746  octave_value obj = args(0);
22747  if ( !obj.is_empty() )
22748  {
22749  if ( obj.is_function_handle() || obj.is_inline_function() )
22750  {
22751  fcnMapForm = obj.function_value();
22752  }
22753  else if ( obj.is_string() )
22754  {
22755  nameMapForm = obj.string_value();
22756  fcnMapForm = NULL;
22757  }
22758  arg1 = mapform_octave;
22759  }
22760  else
22761  {
22762  arg1 = NULL;
22763  }
22764  }
22765  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22766  if (!SWIG_IsOK(res2)) {
22767  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
22768  }
22769  arg2 = (char *)(buf2);
22770  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
22771  if (!SWIG_IsOK(res3)) {
22772  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
22773  }
22774  arg3 = (char *)(buf3);
22775  ecode4 = SWIG_AsVal_double(args(3), &val4);
22776  if (!SWIG_IsOK(ecode4)) {
22777  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
22778  }
22779  arg4 = (PLFLT)(val4);
22780  ecode5 = SWIG_AsVal_double(args(4), &val5);
22781  if (!SWIG_IsOK(ecode5)) {
22782  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
22783  }
22784  arg5 = (PLFLT)(val5);
22785  ecode6 = SWIG_AsVal_double(args(5), &val6);
22786  if (!SWIG_IsOK(ecode6)) {
22787  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
22788  }
22789  arg6 = (PLFLT)(val6);
22790  ecode7 = SWIG_AsVal_double(args(6), &val7);
22791  if (!SWIG_IsOK(ecode7)) {
22792  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
22793  }
22794  arg7 = (PLFLT)(val7);
22795  {
22796  if ( _n_dims( args(7) ) > 1 )
22797  {
22798  error( "argument must be a scalar or vector" ); SWIG_fail;
22799  }
22800  if ( !args(7).is_empty() )
22801  {
22802  arg9 = (PLINT) ( _dim( args(7), 0 ) );
22803  temp8 = args(7).matrix_value();
22804  arg8 = new PLINT[arg9];
22805  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
22806  }
22807  else
22808  {
22809  arg8 = NULL;
22810  arg9 = 0;
22811  }
22812  }
22813  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
22814  _outv = octave_value();
22815  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22816  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22817  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
22818  {
22819  delete [] arg8;
22820  }
22821 fail:
22822  return _out;
22823 }
22824 
22825 
22826 SWIG_DEFUN( plmaptex, _wrap_plmaptex, _wrap_plmaptex_texinfo ) {
22827  mapform_func arg1 = (mapform_func) 0 ;
22828  char *arg2 = (char *) 0 ;
22829  PLFLT arg3 ;
22830  PLFLT arg4 ;
22831  PLFLT arg5 ;
22832  char *arg6 = (char *) 0 ;
22833  PLFLT arg7 ;
22834  PLFLT arg8 ;
22835  PLFLT arg9 ;
22836  PLFLT arg10 ;
22837  PLINT arg11 ;
22838  int res2 ;
22839  char *buf2 = 0 ;
22840  int alloc2 = 0 ;
22841  double val3 ;
22842  int ecode3 = 0 ;
22843  double val4 ;
22844  int ecode4 = 0 ;
22845  double val5 ;
22846  int ecode5 = 0 ;
22847  int res6 ;
22848  char *buf6 = 0 ;
22849  int alloc6 = 0 ;
22850  double val7 ;
22851  int ecode7 = 0 ;
22852  double val8 ;
22853  int ecode8 = 0 ;
22854  double val9 ;
22855  int ecode9 = 0 ;
22856  double val10 ;
22857  int ecode10 = 0 ;
22858  int val11 ;
22859  int ecode11 = 0 ;
22860  octave_value_list _out;
22861  octave_value_list *_outp=&_out;
22862  octave_value _outv;
22863 
22864  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
22865  SWIG_fail;
22866  }
22867  {
22868  octave_value obj = args(0);
22869  if ( !obj.is_empty() )
22870  {
22871  if ( obj.is_function_handle() || obj.is_inline_function() )
22872  {
22873  fcnMapForm = obj.function_value();
22874  }
22875  else if ( obj.is_string() )
22876  {
22877  nameMapForm = obj.string_value();
22878  fcnMapForm = NULL;
22879  }
22880  arg1 = mapform_octave;
22881  }
22882  else
22883  {
22884  arg1 = NULL;
22885  }
22886  }
22887  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22888  if (!SWIG_IsOK(res2)) {
22889  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
22890  }
22891  arg2 = (char *)(buf2);
22892  ecode3 = SWIG_AsVal_double(args(2), &val3);
22893  if (!SWIG_IsOK(ecode3)) {
22894  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
22895  }
22896  arg3 = (PLFLT)(val3);
22897  ecode4 = SWIG_AsVal_double(args(3), &val4);
22898  if (!SWIG_IsOK(ecode4)) {
22899  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
22900  }
22901  arg4 = (PLFLT)(val4);
22902  ecode5 = SWIG_AsVal_double(args(4), &val5);
22903  if (!SWIG_IsOK(ecode5)) {
22904  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
22905  }
22906  arg5 = (PLFLT)(val5);
22907  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22908  if (!SWIG_IsOK(res6)) {
22909  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
22910  }
22911  arg6 = (char *)(buf6);
22912  ecode7 = SWIG_AsVal_double(args(6), &val7);
22913  if (!SWIG_IsOK(ecode7)) {
22914  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
22915  }
22916  arg7 = (PLFLT)(val7);
22917  ecode8 = SWIG_AsVal_double(args(7), &val8);
22918  if (!SWIG_IsOK(ecode8)) {
22919  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
22920  }
22921  arg8 = (PLFLT)(val8);
22922  ecode9 = SWIG_AsVal_double(args(8), &val9);
22923  if (!SWIG_IsOK(ecode9)) {
22924  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
22925  }
22926  arg9 = (PLFLT)(val9);
22927  ecode10 = SWIG_AsVal_double(args(9), &val10);
22928  if (!SWIG_IsOK(ecode10)) {
22929  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
22930  }
22931  arg10 = (PLFLT)(val10);
22932  ecode11 = SWIG_AsVal_int(args(10), &val11);
22933  if (!SWIG_IsOK(ecode11)) {
22934  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
22935  }
22936  arg11 = (PLINT)(val11);
22937  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
22938  _outv = octave_value();
22939  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22940  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22941  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22942 fail:
22943  return _out;
22944 }
22945 
22946 
22947 SWIG_DEFUN( plmapfill, _wrap_plmapfill, _wrap_plmapfill_texinfo ) {
22948  mapform_func arg1 = (mapform_func) 0 ;
22949  char *arg2 = (char *) 0 ;
22950  PLFLT arg3 ;
22951  PLFLT arg4 ;
22952  PLFLT arg5 ;
22953  PLFLT arg6 ;
22954  PLINT *arg7 = (PLINT *) 0 ;
22955  PLINT arg8 ;
22956  int res2 ;
22957  char *buf2 = 0 ;
22958  int alloc2 = 0 ;
22959  double val3 ;
22960  int ecode3 = 0 ;
22961  double val4 ;
22962  int ecode4 = 0 ;
22963  double val5 ;
22964  int ecode5 = 0 ;
22965  double val6 ;
22966  int ecode6 = 0 ;
22967  Matrix temp7 ;
22968  octave_value_list _out;
22969  octave_value_list *_outp=&_out;
22970  octave_value _outv;
22971 
22972  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
22973  SWIG_fail;
22974  }
22975  {
22976  octave_value obj = args(0);
22977  if ( !obj.is_empty() )
22978  {
22979  if ( obj.is_function_handle() || obj.is_inline_function() )
22980  {
22981  fcnMapForm = obj.function_value();
22982  }
22983  else if ( obj.is_string() )
22984  {
22985  nameMapForm = obj.string_value();
22986  fcnMapForm = NULL;
22987  }
22988  arg1 = mapform_octave;
22989  }
22990  else
22991  {
22992  arg1 = NULL;
22993  }
22994  }
22995  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22996  if (!SWIG_IsOK(res2)) {
22997  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
22998  }
22999  arg2 = (char *)(buf2);
23000  ecode3 = SWIG_AsVal_double(args(2), &val3);
23001  if (!SWIG_IsOK(ecode3)) {
23002  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
23003  }
23004  arg3 = (PLFLT)(val3);
23005  ecode4 = SWIG_AsVal_double(args(3), &val4);
23006  if (!SWIG_IsOK(ecode4)) {
23007  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
23008  }
23009  arg4 = (PLFLT)(val4);
23010  ecode5 = SWIG_AsVal_double(args(4), &val5);
23011  if (!SWIG_IsOK(ecode5)) {
23012  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
23013  }
23014  arg5 = (PLFLT)(val5);
23015  ecode6 = SWIG_AsVal_double(args(5), &val6);
23016  if (!SWIG_IsOK(ecode6)) {
23017  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
23018  }
23019  arg6 = (PLFLT)(val6);
23020  {
23021  if ( _n_dims( args(6) ) > 1 )
23022  {
23023  error( "argument must be a scalar or vector" ); SWIG_fail;
23024  }
23025  if ( !args(6).is_empty() )
23026  {
23027  arg8 = (PLINT) ( _dim( args(6), 0 ) );
23028  temp7 = args(6).matrix_value();
23029  arg7 = new PLINT[arg8];
23030  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
23031  }
23032  else
23033  {
23034  arg7 = NULL;
23035  arg8 = 0;
23036  }
23037  }
23038  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
23039  _outv = octave_value();
23040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23041  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23042  {
23043  delete [] arg7;
23044  }
23045 fail:
23046  return _out;
23047 }
23048 
23049 
23050 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
23051  mapform_func arg1 = (mapform_func) 0 ;
23052  PLFLT arg2 ;
23053  PLFLT arg3 ;
23054  PLFLT arg4 ;
23055  PLFLT arg5 ;
23056  PLFLT arg6 ;
23057  PLFLT arg7 ;
23058  double val2 ;
23059  int ecode2 = 0 ;
23060  double val3 ;
23061  int ecode3 = 0 ;
23062  double val4 ;
23063  int ecode4 = 0 ;
23064  double val5 ;
23065  int ecode5 = 0 ;
23066  double val6 ;
23067  int ecode6 = 0 ;
23068  double val7 ;
23069  int ecode7 = 0 ;
23070  octave_value_list _out;
23071  octave_value_list *_outp=&_out;
23072  octave_value _outv;
23073 
23074  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
23075  SWIG_fail;
23076  }
23077  {
23078  octave_value obj = args(0);
23079  if ( !obj.is_empty() )
23080  {
23081  if ( obj.is_function_handle() || obj.is_inline_function() )
23082  {
23083  fcnMapForm = obj.function_value();
23084  }
23085  else if ( obj.is_string() )
23086  {
23087  nameMapForm = obj.string_value();
23088  fcnMapForm = NULL;
23089  }
23090  arg1 = mapform_octave;
23091  }
23092  else
23093  {
23094  arg1 = NULL;
23095  }
23096  }
23097  ecode2 = SWIG_AsVal_double(args(1), &val2);
23098  if (!SWIG_IsOK(ecode2)) {
23099  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
23100  }
23101  arg2 = (PLFLT)(val2);
23102  ecode3 = SWIG_AsVal_double(args(2), &val3);
23103  if (!SWIG_IsOK(ecode3)) {
23104  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
23105  }
23106  arg3 = (PLFLT)(val3);
23107  ecode4 = SWIG_AsVal_double(args(3), &val4);
23108  if (!SWIG_IsOK(ecode4)) {
23109  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
23110  }
23111  arg4 = (PLFLT)(val4);
23112  ecode5 = SWIG_AsVal_double(args(4), &val5);
23113  if (!SWIG_IsOK(ecode5)) {
23114  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
23115  }
23116  arg5 = (PLFLT)(val5);
23117  ecode6 = SWIG_AsVal_double(args(5), &val6);
23118  if (!SWIG_IsOK(ecode6)) {
23119  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
23120  }
23121  arg6 = (PLFLT)(val6);
23122  ecode7 = SWIG_AsVal_double(args(6), &val7);
23123  if (!SWIG_IsOK(ecode7)) {
23124  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
23125  }
23126  arg7 = (PLFLT)(val7);
23127  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23128  _outv = octave_value();
23129  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
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("plClearOpts",args.length(),0,0,0)) {
23141  SWIG_fail;
23142  }
23143  plClearOpts();
23144  _outv = octave_value();
23145  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23146 fail:
23147  return _out;
23148 }
23149 
23150 
23152  octave_value_list _out;
23153  octave_value_list *_outp=&_out;
23154  octave_value _outv;
23155 
23156  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
23157  SWIG_fail;
23158  }
23159  plResetOpts();
23160  _outv = octave_value();
23161  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23162 fail:
23163  return _out;
23164 }
23165 
23166 
23168  char *arg1 = (char *) 0 ;
23169  char *arg2 = (char *) 0 ;
23170  int res1 ;
23171  char *buf1 = 0 ;
23172  int alloc1 = 0 ;
23173  int res2 ;
23174  char *buf2 = 0 ;
23175  int alloc2 = 0 ;
23176  octave_value_list _out;
23177  octave_value_list *_outp=&_out;
23178  octave_value _outv;
23179 
23180  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
23181  SWIG_fail;
23182  }
23183  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23184  if (!SWIG_IsOK(res1)) {
23185  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
23186  }
23187  arg1 = (char *)(buf1);
23188  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23189  if (!SWIG_IsOK(res2)) {
23190  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
23191  }
23192  arg2 = (char *)(buf2);
23193  plSetUsage((char const *)arg1,(char const *)arg2);
23194  _outv = octave_value();
23195  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23196  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23197  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23198 fail:
23199  return _out;
23200 }
23201 
23202 
23204  octave_value_list _out;
23205  octave_value_list *_outp=&_out;
23206  octave_value _outv;
23207 
23208  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
23209  SWIG_fail;
23210  }
23211  plOptUsage();
23212  _outv = octave_value();
23213  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23214 fail:
23215  return _out;
23216 }
23217 
23218 
23219 
23220 static const struct swig_octave_member swig_globals[] = {
23221 {"testppchar",_wrap_testppchar,0,0,2,0},
23222 {"plGetCursor",_wrap_plGetCursor,0,0,2,0},
23223 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
23224 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
23225 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
23226 {"plcont0",_wrap_plcont0,0,0,2,0},
23227 {"plcont1",_wrap_plcont1,0,0,2,0},
23228 {"plcont2",_wrap_plcont2,0,0,2,0},
23229 {"plcont2p",_wrap_plcont2p,0,0,2,0},
23230 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
23231 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
23232 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
23233 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
23234 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
23235 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
23236 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
23237 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
23238 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
23239 {"plshade1",_wrap_plshade1,0,0,2,_wrap_plshade1_texinfo},
23240 {"plshade2",_wrap_plshade2,0,0,2,0},
23241 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
23242 {"plshadesx",_wrap_plshadesx,0,0,2,0},
23243 {"plshades1",_wrap_plshades1,0,0,2,0},
23244 {"plshades2",_wrap_plshades2,0,0,2,0},
23245 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
23246 {"plvect1",_wrap_plvect1,0,0,2,0},
23247 {"plvect2",_wrap_plvect2,0,0,2,0},
23248 {"pplimage",_wrap_pplimage,0,0,2,0},
23249 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
23250 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
23251 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
23252 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
23253 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
23254 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
23255 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
23256 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
23257 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
23258 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
23259 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
23260 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
23261 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
23262 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
23263 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
23264 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
23265 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
23266 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
23267 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
23268 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
23269 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
23270 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
23271 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
23272 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
23273 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
23274 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
23275 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
23276 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
23277 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
23278 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
23279 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
23280 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
23281 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
23282 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
23283 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
23284 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
23285 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
23286 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
23287 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
23288 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
23289 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
23290 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
23291 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
23292 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
23293 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
23294 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
23295 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
23296 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
23297 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
23298 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
23299 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
23300 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
23301 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
23302 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
23303 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
23304 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
23305 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
23306 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
23307 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
23308 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
23309 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
23310 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
23311 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
23312 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
23313 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
23314 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
23315 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
23316 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
23317 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
23318 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
23319 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
23320 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
23321 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
23322 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
23323 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
23324 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
23325 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
23326 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
23327 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
23328 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
23329 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
23330 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
23331 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
23332 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
23333 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
23334 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
23335 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
23336 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
23337 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
23338 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
23339 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
23340 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
23341 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
23342 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
23343 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
23344 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
23345 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
23346 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
23347 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
23348 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
23349 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
23350 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
23351 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
23352 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
23353 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
23354 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
23355 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
23356 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
23357 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
23358 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
23359 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
23360 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
23361 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
23362 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
23363 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
23364 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
23365 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
23366 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
23367 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
23368 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
23369 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
23370 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
23371 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
23372 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
23373 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
23374 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
23375 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
23376 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
23377 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
23378 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
23379 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
23380 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
23381 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
23382 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
23383 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
23384 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
23385 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
23386 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
23387 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
23388 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
23389 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
23390 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
23391 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
23392 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
23393 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
23394 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
23395 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
23396 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
23397 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
23398 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
23399 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
23400 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
23401 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
23402 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
23403 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
23404 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
23405 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
23406 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
23407 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
23408 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
23409 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
23410 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
23411 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
23412 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
23413 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
23414 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
23415 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
23416 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
23417 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
23418 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
23419 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
23420 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
23421 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
23422 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
23423 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
23424 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
23425 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
23426 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
23427 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
23428 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
23429 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
23430 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
23431 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
23432 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
23433 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
23434 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
23435 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
23436 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
23437 {0,0,0,0,0}
23438 };
23439 
23440 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
23441 
23442 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
23443 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
23444 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
23445 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};
23446 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};
23447 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};
23448 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
23449 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
23450 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
23451 
23454  &_swigt__p_char,
23459  &_swigt__p_int,
23462 };
23463 
23464 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23465 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23466 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23470 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23471 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23472 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23473 
23481  _swigc__p_int,
23484 };
23485 
23486 
23487 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23488 
23489 /* -----------------------------------------------------------------------------
23490  * Type initialization:
23491  * This problem is tough by the requirement that no dynamic
23492  * memory is used. Also, since swig_type_info structures store pointers to
23493  * swig_cast_info structures and swig_cast_info structures store pointers back
23494  * to swig_type_info structures, we need some lookup code at initialization.
23495  * The idea is that swig generates all the structures that are needed.
23496  * The runtime then collects these partially filled structures.
23497  * The SWIG_InitializeModule function takes these initial arrays out of
23498  * swig_module, and does all the lookup, filling in the swig_module.types
23499  * array with the correct data and linking the correct swig_cast_info
23500  * structures together.
23501  *
23502  * The generated swig_type_info structures are assigned staticly to an initial
23503  * array. We just loop through that array, and handle each type individually.
23504  * First we lookup if this type has been already loaded, and if so, use the
23505  * loaded structure instead of the generated one. Then we have to fill in the
23506  * cast linked list. The cast data is initially stored in something like a
23507  * two-dimensional array. Each row corresponds to a type (there are the same
23508  * number of rows as there are in the swig_type_initial array). Each entry in
23509  * a column is one of the swig_cast_info structures for that type.
23510  * The cast_initial array is actually an array of arrays, because each row has
23511  * a variable number of columns. So to actually build the cast linked list,
23512  * we find the array of casts associated with the type, and loop through it
23513  * adding the casts to the list. The one last trick we need to do is making
23514  * sure the type pointer in the swig_cast_info struct is correct.
23515  *
23516  * First off, we lookup the cast->type name to see if it is already loaded.
23517  * There are three cases to handle:
23518  * 1) If the cast->type has already been loaded AND the type we are adding
23519  * casting info to has not been loaded (it is in this module), THEN we
23520  * replace the cast->type pointer with the type pointer that has already
23521  * been loaded.
23522  * 2) If BOTH types (the one we are adding casting info to, and the
23523  * cast->type) are loaded, THEN the cast info has already been loaded by
23524  * the previous module so we just ignore it.
23525  * 3) Finally, if cast->type has not already been loaded, then we add that
23526  * swig_cast_info to the linked list (because the cast->type) pointer will
23527  * be correct.
23528  * ----------------------------------------------------------------------------- */
23529 
23530 #ifdef __cplusplus
23531 extern "C" {
23532 #if 0
23533 } /* c-mode */
23534 #endif
23535 #endif
23536 
23537 #if 0
23538 #define SWIGRUNTIME_DEBUG
23539 #endif
23540 
23541 
23542 SWIGRUNTIME void
23543 SWIG_InitializeModule(void *clientdata) {
23544  size_t i;
23545  swig_module_info *module_head, *iter;
23546  int found, init;
23547 
23548  clientdata = clientdata;
23549 
23550  /* check to see if the circular list has been setup, if not, set it up */
23551  if (swig_module.next==0) {
23552  /* Initialize the swig_module */
23553  swig_module.type_initial = swig_type_initial;
23554  swig_module.cast_initial = swig_cast_initial;
23555  swig_module.next = &swig_module;
23556  init = 1;
23557  } else {
23558  init = 0;
23559  }
23560 
23561  /* Try and load any already created modules */
23562  module_head = SWIG_GetModule(clientdata);
23563  if (!module_head) {
23564  /* This is the first module loaded for this interpreter */
23565  /* so set the swig module into the interpreter */
23566  SWIG_SetModule(clientdata, &swig_module);
23567  module_head = &swig_module;
23568  } else {
23569  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23570  found=0;
23571  iter=module_head;
23572  do {
23573  if (iter==&swig_module) {
23574  found=1;
23575  break;
23576  }
23577  iter=iter->next;
23578  } while (iter!= module_head);
23579 
23580  /* if the is found in the list, then all is done and we may leave */
23581  if (found) return;
23582  /* otherwise we must add out module into the list */
23583  swig_module.next = module_head->next;
23584  module_head->next = &swig_module;
23585  }
23586 
23587  /* When multiple interpeters are used, a module could have already been initialized in
23588  a different interpreter, but not yet have a pointer in this interpreter.
23589  In this case, we do not want to continue adding types... everything should be
23590  set up already */
23591  if (init == 0) return;
23592 
23593  /* Now work on filling in swig_module.types */
23594 #ifdef SWIGRUNTIME_DEBUG
23595  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
23596 #endif
23597  for (i = 0; i < swig_module.size; ++i) {
23598  swig_type_info *type = 0;
23599  swig_type_info *ret;
23600  swig_cast_info *cast;
23601 
23602 #ifdef SWIGRUNTIME_DEBUG
23603  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23604 #endif
23605 
23606  /* if there is another module already loaded */
23607  if (swig_module.next != &swig_module) {
23608  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23609  }
23610  if (type) {
23611  /* Overwrite clientdata field */
23612 #ifdef SWIGRUNTIME_DEBUG
23613  printf("SWIG_InitializeModule: found type %s\n", type->name);
23614 #endif
23615  if (swig_module.type_initial[i]->clientdata) {
23616  type->clientdata = swig_module.type_initial[i]->clientdata;
23617 #ifdef SWIGRUNTIME_DEBUG
23618  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23619 #endif
23620  }
23621  } else {
23622  type = swig_module.type_initial[i];
23623  }
23624 
23625  /* Insert casting types */
23626  cast = swig_module.cast_initial[i];
23627  while (cast->type) {
23628 
23629  /* Don't need to add information already in the list */
23630  ret = 0;
23631 #ifdef SWIGRUNTIME_DEBUG
23632  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23633 #endif
23634  if (swig_module.next != &swig_module) {
23635  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
23636 #ifdef SWIGRUNTIME_DEBUG
23637  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23638 #endif
23639  }
23640  if (ret) {
23641  if (type == swig_module.type_initial[i]) {
23642 #ifdef SWIGRUNTIME_DEBUG
23643  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23644 #endif
23645  cast->type = ret;
23646  ret = 0;
23647  } else {
23648  /* Check for casting already in the list */
23649  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23650 #ifdef SWIGRUNTIME_DEBUG
23651  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23652 #endif
23653  if (!ocast) ret = 0;
23654  }
23655  }
23656 
23657  if (!ret) {
23658 #ifdef SWIGRUNTIME_DEBUG
23659  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23660 #endif
23661  if (type->cast) {
23662  type->cast->prev = cast;
23663  cast->next = type->cast;
23664  }
23665  type->cast = cast;
23666  }
23667  cast++;
23668  }
23669  /* Set entry in modules->types array equal to the type */
23670  swig_module.types[i] = type;
23671  }
23672  swig_module.types[i] = 0;
23673 
23674 #ifdef SWIGRUNTIME_DEBUG
23675  printf("**** SWIG_InitializeModule: Cast List ******\n");
23676  for (i = 0; i < swig_module.size; ++i) {
23677  int j = 0;
23678  swig_cast_info *cast = swig_module.cast_initial[i];
23679  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
23680  while (cast->type) {
23681  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23682  cast++;
23683  ++j;
23684  }
23685  printf("---- Total casts: %d\n",j);
23686  }
23687  printf("**** SWIG_InitializeModule: Cast List ******\n");
23688 #endif
23689 }
23690 
23691 /* This function will propagate the clientdata field of type to
23692 * any new swig_type_info structures that have been added into the list
23693 * of equivalent types. It is like calling
23694 * SWIG_TypeClientData(type, clientdata) a second time.
23695 */
23696 SWIGRUNTIME void
23698  size_t i;
23699  swig_cast_info *equiv;
23700  static int init_run = 0;
23701 
23702  if (init_run) return;
23703  init_run = 1;
23704 
23705  for (i = 0; i < swig_module.size; i++) {
23706  if (swig_module.types[i]->clientdata) {
23707  equiv = swig_module.types[i]->cast;
23708  while (equiv) {
23709  if (!equiv->converter) {
23710  if (equiv->type && !equiv->type->clientdata)
23711  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23712  }
23713  equiv = equiv->next;
23714  }
23715  }
23716  }
23717 }
23718 
23719 #ifdef __cplusplus
23720 #if 0
23721 { /* c-mode */
23722 #endif
23723 }
23724 #endif
23725 
23726 
23727 
23728 static void SWIG_init_user(octave_swig_type* module_ns);
23729 
23730 SWIGINTERN void SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
23731  octave_value_list args;
23732  args.append(name);
23733  args.append(octloadfcn->fcn_file_name());
23734  feval("autoload", args, 0);
23735 }
23736 
23737 static const char *const subclass_usage = "-*- texinfo -*- \n\
23738 @deftypefn {Loadable Function} {} subclass()\n\
23739 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
23740 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
23741 \n\
23742 See the SWIG manual for usage examples.\n\
23743 @end deftypefn";
23744 
23745 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
23747  for (int j = 0; j < args.length(); ++j) {
23748  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
23749  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
23750  octave_swig_type *ost = osr->get_ptr();
23751  if (!ost->is_owned()) {
23752  error("cannot subclass object not constructed on octave side");
23753  return octave_value_list();
23754  }
23755  top->merge(*ost);
23756  } else if (args(j).is_function_handle()) {
23757  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
23758  } else if (args(j).is_string()) {
23759  if (j + 1 >= args.length()) {
23760  error("member assignments must be of string,value form");
23761  return octave_value_list();
23762  }
23763  top->assign(args(j).string_value(), args(j + 1));
23764  ++j;
23765  } else {
23766  error("invalid arguments to subclass()");
23767  return octave_value_list();
23768  }
23769  }
23770  return octave_value(Swig::swig_value_ref(top));
23771 }
23772 
23773 static const char *const swig_type_usage = "-*- texinfo -*- \n\
23774 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
23775 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
23776 @end deftypefn";
23777 
23778 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
23779  if (args.length() != 1) {
23780  error("swig_type() must be called with only a single object");
23781  return octave_value_list();
23782  }
23783  octave_swig_type *ost = Swig::swig_value_deref(args(0));
23784  if (!ost) {
23785  error("object is not a swig_ref");
23786  return octave_value_list();
23787  }
23788  return octave_value(ost->swig_type_name());
23789 }
23790 
23791 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
23792 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
23793 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
23794 otherwise return `<unknown>'.\n\
23795 @end deftypefn";
23796 
23797 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
23798  if (args.length() != 1 || !args(0).is_string()) {
23799  error("swig_typequery() must be called with single string argument");
23800  return octave_value_list();
23801  }
23802  swig_module_info *module = SWIG_GetModule(0);
23803  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
23804  if (!type)
23805  return octave_value("<unknown>");
23806  return octave_value(type->name);
23807 }
23808 
23809 static const char *const swig_this_usage = "-*- texinfo -*- \n\
23810 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
23811 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
23812 @end deftypefn";
23813 
23814 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
23815  if (args.length() != 1) {
23816  error("swig_this() must be called with only a single object");
23817  return octave_value_list();
23818  }
23819  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
23820  return octave_value(octave_uint64(0));
23821  octave_swig_type *ost = Swig::swig_value_deref(args(0));
23822  if (!ost) {
23823  error("object is not a swig_ref");
23824  return octave_value_list();
23825  }
23826  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
23827 }
23828 
23829 // workaround to prevent octave seg-faulting on exit: register at-exit
23830 // function which exits octave immediately without trying to cleanup memory.
23831 // definitely affects version 3.2.*, not sure about 3.3.*, seems to be
23832 // fixed in version 3.4.* and above. can be turned on/off with macros.
23833 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
23834 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
23835 #define SWIG_OCTAVE_SEGFAULT_HACK
23836 #endif
23837 #endif
23838 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23839 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
23840 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
23842  _exit(exit_status);
23843 }
23844 #endif
23845 
23846 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
23847 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
23848 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
23849 \n\
23850 To load the module into the global namespace:\n\
23851 @example\n\
23852 " SWIG_name_d ";\n\
23853 @end example\n\
23854 To access the module through a local variable, without loading it globally:\n\
23855 @example\n\
23856 " SWIG_name_d " = " SWIG_name_d ";\n\
23857 @end example\n\
23858 To access the module locally through a variable named, e.g. @var{modl}:\n\
23859 @example\n\
23860 @var{modl} = " SWIG_name_d ";\n\
23861 @end example\n\
23862 @end deftypefn";
23863 
23864 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
23865 
23866  static octave_swig_type* module_ns = 0;
23867  octave_value_list retval;
23868 
23869  // create module on first function call
23870  if (!module_ns) {
23871 
23872 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
23874 #endif
23875 
23876  // workaround bug in octave where installing global variable of custom type and then
23877  // exiting without explicitly clearing the variable causes octave to segfault.
23878 #if OCTAVE_API_VERSION_NUMBER >= 37
23879  octave_value_list eval_args;
23880  eval_args.append("base");
23881  eval_args.append("function __swig_atexit__; "
23882  " if mislocked() "
23883  " clear -all; "
23884  " else "
23885  " mlock(); "
23886  " endif; "
23887  "endfunction; "
23888  "__swig_atexit__; "
23889  "atexit(\"__swig_atexit__\", false); "
23890  "atexit(\"__swig_atexit__\")");
23891  feval("evalin", eval_args, 0);
23892 #endif
23893 
23894  octave_swig_ref::register_type();
23895  octave_swig_packed::register_type();
23898 
23899  octave_function *me = octave_call_stack::current();
23900 
23901  SWIG_Octave_InstallFunction(me, "swig_type");
23902  SWIG_Octave_InstallFunction(me, "swig_typequery");
23903  SWIG_Octave_InstallFunction(me, "swig_this");
23904  SWIG_Octave_InstallFunction(me, "subclass");
23905 
23906  octave_swig_type* cvar_ns=0;
23907  if (std::string(SWIG_global_name) != ".") {
23908  cvar_ns=new octave_swig_type;
23909  for (int j=0;swig_globals[j].name;++j)
23910  if (swig_globals[j].get_method)
23911  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
23912  }
23913 
23914  module_ns=new octave_swig_type(0, 0, 0, true);
23915  if (std::string(SWIG_global_name) != ".") {
23916  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
23917  }
23918  else {
23919  for (int j=0;swig_globals[j].name;++j)
23920  if (swig_globals[j].get_method)
23921  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
23922  }
23923  for (int j=0;swig_globals[j].name;++j)
23924  if (swig_globals[j].method)
23925  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
23926 
23927  // * need better solution here; swig_type -> octave_class mapping is
23928  // * really n-to-1, in some cases such as template partial spec, etc.
23929  // * see failing tests.
23930  for (int j=0;swig_types[j];++j)
23931  if (swig_types[j]->clientdata) {
23932  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
23933  module_ns->assign(c->name,
23935  (new octave_swig_type(0,swig_types[j])));
23936  }
23937 
23938  SWIG_init_user(module_ns);
23939 
23940  SWIG_InstallOps(octave_swig_ref::static_type_id());
23941 
23942 #if OCTAVE_API_VERSION_NUMBER < 37
23943  mlock(me->name());
23944 #else
23945  mlock();
23946 #endif
23947 
23948  }
23949 
23950  // return module if asked for
23951  if (args.length() == 0 && nargout == 1) {
23952  retval = octave_value(module_ns->as_value());
23953  }
23954 
23955  // if call with not output arguments, load globally
23956  else if (args.length() == 0 && nargout == 0) {
23957 
23958  octave_function *me = octave_call_stack::current();
23959 
23961  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
23962  if (mb->second.first && mb->second.first->method) {
23963  SWIG_Octave_InstallFunction(me, mb->first);
23964  }
23965  else if (mb->second.second.is_defined()) {
23966  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
23967  SWIG_Octave_LinkGlobalValue(mb->first);
23968  }
23969  }
23970 
23971  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
23972  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
23973 
23974  }
23975 
23976  // otherwise print usage
23977  else {
23978  print_usage();
23979  }
23980 
23981  return retval;
23982 
23983 }
23984 
23985 
23986 static void SWIG_init_user(octave_swig_type* module_ns)
23987 {
23988  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
23989  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23990  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
23991  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
23992  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
23993  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
23994  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
23995  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
23996  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
23997  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
23998  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
23999  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
24000  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
24001  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
24002  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
24003  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
24004  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
24005  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
24006  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
24007  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
24008  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
24009  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
24010  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
24011  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
24012  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int((int)(25)));
24013  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int((int)(26)));
24014  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int((int)(27)));
24015  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
24016  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
24017  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
24018  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int((int)(31)));
24019  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
24020  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
24021  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int((int)(34)));
24022  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int((int)(35)));
24023  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int((int)(36)));
24024  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int((int)(37)));
24025  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int((int)(38)));
24026  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
24027  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
24028  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
24029  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
24030  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
24031  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
24032  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
24033  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
24034  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
24035  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int((int)(1)));
24036  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int((int)(2)));
24037  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int((int)(3)));
24038  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int((int)(4)));
24039  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
24040  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
24041  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
24042  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
24043  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
24044  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
24045  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
24046  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
24047  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
24048  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
24049  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
24050  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
24051  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
24052  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
24053  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
24054  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
24055  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
24056  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
24057  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
24058  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
24059  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
24060  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
24061  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
24062  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
24063  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
24064  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
24065  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
24066  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
24067  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
24068  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
24069  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
24070  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
24071  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
24072  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
24073  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
24074  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
24075  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
24076  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
24077  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
24078  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
24079  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
24080  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
24081  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
24082  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
24083  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
24084  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
24085  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
24086  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
24087  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
24088  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
24089  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
24090  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
24091  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
24092  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
24093  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
24094  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
24095  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
24096  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
24097  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
24098  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
24099  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
24100  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
24101  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
24102  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
24103  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
24104  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
24105  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
24106  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
24107  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
24108  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
24109  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
24110  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
24111  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
24112  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
24113  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
24114  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
24115  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
24116  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
24117  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
24118  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
24119  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
24120  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
24121  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
24122  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
24123  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
24124  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
24125  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
24126  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
24127  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
24128  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
24129  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
24130  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
24131  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
24132  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
24133  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
24134  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
24135  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
24136  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
24137  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
24138  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
24139  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x001)));
24140  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x002)));
24141  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x003)));
24142  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x004)));
24143  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x008)));
24144  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x010)));
24145  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x020)));
24146  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x040)));
24147  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x080)));
24148  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
24149 }
24150