PLplot  5.12.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplot_octaveOCTAVE_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.12
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 <cstdlib>
153 #include <iostream>
154 #include <octave/oct.h>
155 #include <octave/Cell.h>
156 #include <octave/dynamic-ld.h>
157 #include <octave/oct-env.h>
158 #include <octave/oct-map.h>
159 #include <octave/ov-fcn-handle.h>
160 #include <octave/parse.h>
161 #include <octave/toplev.h>
162 #include <octave/unwind-prot.h>
163 
164 /* -----------------------------------------------------------------------------
165  * swigrun.swg
166  *
167  * This file contains generic C API SWIG runtime support for pointer
168  * type checking.
169  * ----------------------------------------------------------------------------- */
170 
171 /* This should only be incremented when either the layout of swig_type_info changes,
172  or for whatever reason, the runtime changes incompatibly */
173 #define SWIG_RUNTIME_VERSION "4"
174 
175 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
176 #ifdef SWIG_TYPE_TABLE
177 # define SWIG_QUOTE_STRING(x) #x
178 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
179 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
180 #else
181 # define SWIG_TYPE_TABLE_NAME
182 #endif
183 
184 /*
185  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
186  creating a static or dynamic library from the SWIG runtime code.
187  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
188 
189  But only do this if strictly necessary, ie, if you have problems
190  with your compiler or suchlike.
191 */
192 
193 #ifndef SWIGRUNTIME
194 # define SWIGRUNTIME SWIGINTERN
195 #endif
196 
197 #ifndef SWIGRUNTIMEINLINE
198 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
199 #endif
200 
201 /* Generic buffer size */
202 #ifndef SWIG_BUFFER_SIZE
203 # define SWIG_BUFFER_SIZE 1024
204 #endif
205 
206 /* Flags for pointer conversions */
207 #define SWIG_POINTER_DISOWN 0x1
208 #define SWIG_CAST_NEW_MEMORY 0x2
209 
210 /* Flags for new pointer objects */
211 #define SWIG_POINTER_OWN 0x1
212 
213 
214 /*
215  Flags/methods for returning states.
216 
217  The SWIG conversion methods, as ConvertPtr, return an integer
218  that tells if the conversion was successful or not. And if not,
219  an error code can be returned (see swigerrors.swg for the codes).
220 
221  Use the following macros/flags to set or process the returning
222  states.
223 
224  In old versions of SWIG, code such as the following was usually written:
225 
226  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
227  // success code
228  } else {
229  //fail code
230  }
231 
232  Now you can be more explicit:
233 
234  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
235  if (SWIG_IsOK(res)) {
236  // success code
237  } else {
238  // fail code
239  }
240 
241  which is the same really, but now you can also do
242 
243  Type *ptr;
244  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
245  if (SWIG_IsOK(res)) {
246  // success code
247  if (SWIG_IsNewObj(res) {
248  ...
249  delete *ptr;
250  } else {
251  ...
252  }
253  } else {
254  // fail code
255  }
256 
257  I.e., now SWIG_ConvertPtr can return new objects and you can
258  identify the case and take care of the deallocation. Of course that
259  also requires SWIG_ConvertPtr to return new result values, such as
260 
261  int SWIG_ConvertPtr(obj, ptr,...) {
262  if (<obj is ok>) {
263  if (<need new object>) {
264  *ptr = <ptr to new allocated object>;
265  return SWIG_NEWOBJ;
266  } else {
267  *ptr = <ptr to old object>;
268  return SWIG_OLDOBJ;
269  }
270  } else {
271  return SWIG_BADOBJ;
272  }
273  }
274 
275  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
276  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
277  SWIG errors code.
278 
279  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
280  allows to return the 'cast rank', for example, if you have this
281 
282  int food(double)
283  int fooi(int);
284 
285  and you call
286 
287  food(1) // cast rank '1' (1 -> 1.0)
288  fooi(1) // cast rank '0'
289 
290  just use the SWIG_AddCast()/SWIG_CheckState()
291 */
292 
293 #define SWIG_OK (0)
294 #define SWIG_ERROR (-1)
295 #define SWIG_IsOK(r) (r >= 0)
296 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
297 
298 /* The CastRankLimit says how many bits are used for the cast rank */
299 #define SWIG_CASTRANKLIMIT (1 << 8)
300 /* The NewMask denotes the object was created (using new/malloc) */
301 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
302 /* The TmpMask is for in/out typemaps that use temporal objects */
303 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
304 /* Simple returning values */
305 #define SWIG_BADOBJ (SWIG_ERROR)
306 #define SWIG_OLDOBJ (SWIG_OK)
307 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
308 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
309 /* Check, add and del mask methods */
310 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
311 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
312 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
313 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
314 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
315 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
316 
317 /* Cast-Rank Mode */
318 #if defined(SWIG_CASTRANK_MODE)
319 # ifndef SWIG_TypeRank
320 # define SWIG_TypeRank unsigned long
321 # endif
322 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
323 # define SWIG_MAXCASTRANK (2)
324 # endif
325 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
326 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
327 SWIGINTERNINLINE int SWIG_AddCast(int r) {
328  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
329 }
331  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
332 }
333 #else /* no cast-rank mode */
334 # define SWIG_AddCast(r) (r)
335 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
336 #endif
337 
338 
339 #include <string.h>
340 
341 #ifdef __cplusplus
342 extern "C" {
343 #endif
344 
345 typedef void *(*swig_converter_func)(void *, int *);
346 typedef struct swig_type_info *(*swig_dycast_func)(void **);
347 
348 /* Structure to store information on one type */
349 typedef struct swig_type_info {
350  const char *name; /* mangled name of this type */
351  const char *str; /* human readable name of this type */
352  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
353  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
354  void *clientdata; /* language specific type data */
355  int owndata; /* flag if the structure owns the clientdata */
357 
358 /* Structure to store a type and conversion function used for casting */
359 typedef struct swig_cast_info {
360  swig_type_info *type; /* pointer to type that is equivalent to this type */
361  swig_converter_func converter; /* function to cast the void pointers */
362  struct swig_cast_info *next; /* pointer to next cast in linked list */
363  struct swig_cast_info *prev; /* pointer to the previous cast */
365 
366 /* Structure used to store module information
367  * Each module generates one structure like this, and the runtime collects
368  * all of these structures and stores them in a circularly linked list.*/
369 typedef struct swig_module_info {
370  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
371  size_t size; /* Number of types in this module */
372  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
373  swig_type_info **type_initial; /* Array of initially generated type structures */
374  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
375  void *clientdata; /* Language specific module data */
377 
378 /*
379  Compare two type names skipping the space characters, therefore
380  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
381 
382  Return 0 when the two name types are equivalent, as in
383  strncmp, but skipping ' '.
384 */
385 SWIGRUNTIME int
386 SWIG_TypeNameComp(const char *f1, const char *l1,
387  const char *f2, const char *l2) {
388  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
389  while ((*f1 == ' ') && (f1 != l1)) ++f1;
390  while ((*f2 == ' ') && (f2 != l2)) ++f2;
391  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
392  }
393  return (int)((l1 - f1) - (l2 - f2));
394 }
395 
396 /*
397  Check type equivalence in a name list like <name1>|<name2>|...
398  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
399 */
400 SWIGRUNTIME int
401 SWIG_TypeCmp(const char *nb, const char *tb) {
402  int equiv = 1;
403  const char* te = tb + strlen(tb);
404  const char* ne = nb;
405  while (equiv != 0 && *ne) {
406  for (nb = ne; *ne; ++ne) {
407  if (*ne == '|') break;
408  }
409  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
410  if (*ne) ++ne;
411  }
412  return equiv;
413 }
414 
415 /*
416  Check type equivalence in a name list like <name1>|<name2>|...
417  Return 0 if not equal, 1 if equal
418 */
419 SWIGRUNTIME int
420 SWIG_TypeEquiv(const char *nb, const char *tb) {
421  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
422 }
423 
424 /*
425  Check the typename
426 */
428 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
429  if (ty) {
430  swig_cast_info *iter = ty->cast;
431  while (iter) {
432  if (strcmp(iter->type->name, c) == 0) {
433  if (iter == ty->cast)
434  return iter;
435  /* Move iter to the top of the linked list */
436  iter->prev->next = iter->next;
437  if (iter->next)
438  iter->next->prev = iter->prev;
439  iter->next = ty->cast;
440  iter->prev = 0;
441  if (ty->cast) ty->cast->prev = iter;
442  ty->cast = iter;
443  return iter;
444  }
445  iter = iter->next;
446  }
447  }
448  return 0;
449 }
450 
451 /*
452  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
453 */
456  if (ty) {
457  swig_cast_info *iter = ty->cast;
458  while (iter) {
459  if (iter->type == from) {
460  if (iter == ty->cast)
461  return iter;
462  /* Move iter to the top of the linked list */
463  iter->prev->next = iter->next;
464  if (iter->next)
465  iter->next->prev = iter->prev;
466  iter->next = ty->cast;
467  iter->prev = 0;
468  if (ty->cast) ty->cast->prev = iter;
469  ty->cast = iter;
470  return iter;
471  }
472  iter = iter->next;
473  }
474  }
475  return 0;
476 }
477 
478 /*
479  Cast a pointer up an inheritance hierarchy
480 */
481 SWIGRUNTIMEINLINE void *
482 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
483  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
484 }
485 
486 /*
487  Dynamic pointer casting. Down an inheritance hierarchy
488 */
491  swig_type_info *lastty = ty;
492  if (!ty || !ty->dcast) return ty;
493  while (ty && (ty->dcast)) {
494  ty = (*ty->dcast)(ptr);
495  if (ty) lastty = ty;
496  }
497  return lastty;
498 }
499 
500 /*
501  Return the name associated with this type
502 */
503 SWIGRUNTIMEINLINE const char *
505  return ty->name;
506 }
507 
508 /*
509  Return the pretty name associated with this type,
510  that is an unmangled type name in a form presentable to the user.
511 */
512 SWIGRUNTIME const char *
514  /* The "str" field contains the equivalent pretty names of the
515  type, separated by vertical-bar characters. We choose
516  to print the last name, as it is often (?) the most
517  specific. */
518  if (!type) return NULL;
519  if (type->str != NULL) {
520  const char *last_name = type->str;
521  const char *s;
522  for (s = type->str; *s; s++)
523  if (*s == '|') last_name = s+1;
524  return last_name;
525  }
526  else
527  return type->name;
528 }
529 
530 /*
531  Set the clientdata field for a type
532 */
533 SWIGRUNTIME void
535  swig_cast_info *cast = ti->cast;
536  /* if (ti->clientdata == clientdata) return; */
537  ti->clientdata = clientdata;
538 
539  while (cast) {
540  if (!cast->converter) {
541  swig_type_info *tc = cast->type;
542  if (!tc->clientdata) {
543  SWIG_TypeClientData(tc, clientdata);
544  }
545  }
546  cast = cast->next;
547  }
548 }
549 SWIGRUNTIME void
551  SWIG_TypeClientData(ti, clientdata);
552  ti->owndata = 1;
553 }
554 
555 /*
556  Search for a swig_type_info structure only by mangled name
557  Search is a O(log #types)
558 
559  We start searching at module start, and finish searching when start == end.
560  Note: if start == end at the beginning of the function, we go all the way around
561  the circular list.
562 */
565  swig_module_info *end,
566  const char *name) {
567  swig_module_info *iter = start;
568  do {
569  if (iter->size) {
570  register size_t l = 0;
571  register size_t r = iter->size - 1;
572  do {
573  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
574  register size_t i = (l + r) >> 1;
575  const char *iname = iter->types[i]->name;
576  if (iname) {
577  register int compare = strcmp(name, iname);
578  if (compare == 0) {
579  return iter->types[i];
580  } else if (compare < 0) {
581  if (i) {
582  r = i - 1;
583  } else {
584  break;
585  }
586  } else if (compare > 0) {
587  l = i + 1;
588  }
589  } else {
590  break; /* should never happen */
591  }
592  } while (l <= r);
593  }
594  iter = iter->next;
595  } while (iter != end);
596  return 0;
597 }
598 
599 /*
600  Search for a swig_type_info structure for either a mangled name or a human readable name.
601  It first searches the mangled names of the types, which is a O(log #types)
602  If a type is not found it then searches the human readable names, which is O(#types).
603 
604  We start searching at module start, and finish searching when start == end.
605  Note: if start == end at the beginning of the function, we go all the way around
606  the circular list.
607 */
610  swig_module_info *end,
611  const char *name) {
612  /* STEP 1: Search the name field using binary search */
613  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
614  if (ret) {
615  return ret;
616  } else {
617  /* STEP 2: If the type hasn't been found, do a complete search
618  of the str field (the human readable name) */
619  swig_module_info *iter = start;
620  do {
621  register size_t i = 0;
622  for (; i < iter->size; ++i) {
623  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
624  return iter->types[i];
625  }
626  iter = iter->next;
627  } while (iter != end);
628  }
629 
630  /* neither found a match */
631  return 0;
632 }
633 
634 /*
635  Pack binary data into a string
636 */
637 SWIGRUNTIME char *
638 SWIG_PackData(char *c, void *ptr, size_t sz) {
639  static const char hex[17] = "0123456789abcdef";
640  register const unsigned char *u = (unsigned char *) ptr;
641  register const unsigned char *eu = u + sz;
642  for (; u != eu; ++u) {
643  register unsigned char uu = *u;
644  *(c++) = hex[(uu & 0xf0) >> 4];
645  *(c++) = hex[uu & 0xf];
646  }
647  return c;
648 }
649 
650 /*
651  Unpack binary data from a string
652 */
653 SWIGRUNTIME const char *
654 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
655  register unsigned char *u = (unsigned char *) ptr;
656  register const unsigned char *eu = u + sz;
657  for (; u != eu; ++u) {
658  register char d = *(c++);
659  register unsigned char uu;
660  if ((d >= '0') && (d <= '9'))
661  uu = ((d - '0') << 4);
662  else if ((d >= 'a') && (d <= 'f'))
663  uu = ((d - ('a'-10)) << 4);
664  else
665  return (char *) 0;
666  d = *(c++);
667  if ((d >= '0') && (d <= '9'))
668  uu |= (d - '0');
669  else if ((d >= 'a') && (d <= 'f'))
670  uu |= (d - ('a'-10));
671  else
672  return (char *) 0;
673  *u = uu;
674  }
675  return c;
676 }
677 
678 /*
679  Pack 'void *' into a string buffer.
680 */
681 SWIGRUNTIME char *
682 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
683  char *r = buff;
684  if ((2*sizeof(void *) + 2) > bsz) return 0;
685  *(r++) = '_';
686  r = SWIG_PackData(r,&ptr,sizeof(void *));
687  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
688  strcpy(r,name);
689  return buff;
690 }
691 
692 SWIGRUNTIME const char *
693 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
694  if (*c != '_') {
695  if (strcmp(c,"NULL") == 0) {
696  *ptr = (void *) 0;
697  return name;
698  } else {
699  return 0;
700  }
701  }
702  return SWIG_UnpackData(++c,ptr,sizeof(void *));
703 }
704 
705 SWIGRUNTIME char *
706 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
707  char *r = buff;
708  size_t lname = (name ? strlen(name) : 0);
709  if ((2*sz + 2 + lname) > bsz) return 0;
710  *(r++) = '_';
711  r = SWIG_PackData(r,ptr,sz);
712  if (lname) {
713  strncpy(r,name,lname+1);
714  } else {
715  *r = 0;
716  }
717  return buff;
718 }
719 
720 SWIGRUNTIME const char *
721 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
722  if (*c != '_') {
723  if (strcmp(c,"NULL") == 0) {
724  memset(ptr,0,sz);
725  return name;
726  } else {
727  return 0;
728  }
729  }
730  return SWIG_UnpackData(++c,ptr,sz);
731 }
732 
733 #ifdef __cplusplus
734 }
735 #endif
736 
737 /* Errors in SWIG */
738 #define SWIG_UnknownError -1
739 #define SWIG_IOError -2
740 #define SWIG_RuntimeError -3
741 #define SWIG_IndexError -4
742 #define SWIG_TypeError -5
743 #define SWIG_DivisionByZero -6
744 #define SWIG_OverflowError -7
745 #define SWIG_SyntaxError -8
746 #define SWIG_ValueError -9
747 #define SWIG_SystemError -10
748 #define SWIG_AttributeError -11
749 #define SWIG_MemoryError -12
750 #define SWIG_NullReferenceError -13
751 
752 
753 
754 
755 #include <octave/version.h>
756 
757 // Macro for enabling features which require Octave version >= major.minor.patch
758 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
759  ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + OCTAVE_PATCH_VERSION >= ((major)<<16) + ((minor)<<8) + (patch) )
760 
761 // Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
762 #if !defined(OCTAVE_MAJOR_VERSION)
763 
764 # if !defined(OCTAVE_API_VERSION_NUMBER)
765 
766 // Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
767 // introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
768 # include <octave/ov.h>
769 # if defined(octave_ov_h)
770 # define OCTAVE_MAJOR_VERSION 3
771 # define OCTAVE_MINOR_VERSION 8
772 # define OCTAVE_PATCH_VERSION 0
773 # else
774 
775 // Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
776 # define ComplexLU __ignore
777 # include <octave/CmplxLU.h>
778 # undef ComplexLU
779 # if defined(octave_Complex_LU_h)
780 
781 // We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
782 # define OCTAVE_MAJOR_VERSION 3
783 # define OCTAVE_MINOR_VERSION 1
784 # define OCTAVE_PATCH_VERSION 99
785 
786 # else
787 
788 // OCTAVE_API_VERSION_NUMBER == 37
789 # define OCTAVE_MAJOR_VERSION 3
790 # define OCTAVE_MINOR_VERSION 2
791 # define OCTAVE_PATCH_VERSION 0
792 
793 # endif // defined(octave_Complex_LU_h)
794 
795 # endif // defined(octave_ov_h)
796 
797 // Correlation between Octave API and version numbers extracted from Octave's
798 // ChangeLogs; version is the *earliest* released Octave with that API number
799 # elif OCTAVE_API_VERSION_NUMBER >= 48
800 # define OCTAVE_MAJOR_VERSION 3
801 # define OCTAVE_MINOR_VERSION 6
802 # define OCTAVE_PATCH_VERSION 0
803 
804 # elif OCTAVE_API_VERSION_NUMBER >= 45
805 # define OCTAVE_MAJOR_VERSION 3
806 # define OCTAVE_MINOR_VERSION 4
807 # define OCTAVE_PATCH_VERSION 1
808 
809 # elif OCTAVE_API_VERSION_NUMBER >= 42
810 # define OCTAVE_MAJOR_VERSION 3
811 # define OCTAVE_MINOR_VERSION 3
812 # define OCTAVE_PATCH_VERSION 54
813 
814 # elif OCTAVE_API_VERSION_NUMBER >= 41
815 # define OCTAVE_MAJOR_VERSION 3
816 # define OCTAVE_MINOR_VERSION 3
817 # define OCTAVE_PATCH_VERSION 53
818 
819 # elif OCTAVE_API_VERSION_NUMBER >= 40
820 # define OCTAVE_MAJOR_VERSION 3
821 # define OCTAVE_MINOR_VERSION 3
822 # define OCTAVE_PATCH_VERSION 52
823 
824 # elif OCTAVE_API_VERSION_NUMBER >= 39
825 # define OCTAVE_MAJOR_VERSION 3
826 # define OCTAVE_MINOR_VERSION 3
827 # define OCTAVE_PATCH_VERSION 51
828 
829 # else // OCTAVE_API_VERSION_NUMBER == 38
830 # define OCTAVE_MAJOR_VERSION 3
831 # define OCTAVE_MINOR_VERSION 3
832 # define OCTAVE_PATCH_VERSION 50
833 
834 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
835 
836 #endif // !defined(OCTAVE_MAJOR_VERSION)
837 
838 #if !SWIG_OCTAVE_PREREQ(3,2,0)
839 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
840 #else
841 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
842 #endif
843 
844 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
845  if (num_args > max_args && !varargs)
846  error("function %s takes at most %i arguments", func_name, max_args);
847  else if (num_args < min_args)
848  error("function %s requires at least %i arguments", func_name, min_args);
849  else
850  return true;
851  return false;
852 }
853 
854 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
855  ovl->append(ov);
856  return ovl;
857 }
858 
859 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
860  switch (code) {
861  case SWIG_MemoryError:
862  return "SWIG_MemoryError";
863  case SWIG_IOError:
864  return "SWIG_IOError";
865  case SWIG_RuntimeError:
866  return "SWIG_RuntimeError";
867  case SWIG_IndexError:
868  return "SWIG_IndexError";
869  case SWIG_TypeError:
870  return "SWIG_TypeError";
871  case SWIG_DivisionByZero:
872  return "SWIG_DivisionByZero";
873  case SWIG_OverflowError:
874  return "SWIG_OverflowError";
875  case SWIG_SyntaxError:
876  return "SWIG_SyntaxError";
877  case SWIG_ValueError:
878  return "SWIG_ValueError";
879  case SWIG_SystemError:
880  return "SWIG_SystemError";
881  case SWIG_AttributeError:
882  return "SWIG_AttributeError";
883  }
884  return "SWIG unknown error";
885 }
886 
887 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
888  octave_value type(SWIG_ErrorType(code));
889  std::string r = msg;
890  r += " (" + type.string_value() + ")";
891  error(r.c_str());
892  return octave_value(r);
893 }
894 
895 #define SWIG_fail goto fail
896 
897 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
898 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
899 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
900 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
901 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
902 #define swig_owntype int
903 
904 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
905 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
906 
907 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
908 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
909 
910 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
911 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
912 
913 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
914 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
915 #define SWIG_MODULE_CLIENTDATA_TYPE void*
916 
917 #define Octave_Error_Occurred() 0
918 #define SWIG_Octave_AddErrorMsg(msg) {;}
919 
922 
923 // For backward compatibility only
924 #define SWIG_POINTER_EXCEPTION 0
925 #define SWIG_arg_fail(arg) 0
926 
927 // Runtime API implementation
928 
929 #include <map>
930 #include <vector>
931 #include <string>
932 
933 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
934 class octave_swig_type;
935 
936 namespace Swig {
937 
938 #ifdef SWIG_DIRECTORS
939 
940  class Director;
941 
942  typedef std::map < void *, Director * > rtdir_map;
943  SWIGINTERN rtdir_map* get_rtdir_map();
944  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
945  SWIGINTERNINLINE void erase_rtdir(void *vptr);
946  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
947 
948  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
949  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
950  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
951 
952 #endif
953 
954  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
956  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
957 }
958 
959 #ifdef SWIG_DIRECTORS
960 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
961 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
962 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
963 #endif
964 
966  const char *name;
970  int flags; // 1 static, 2 global
971  const char *doc;
972  bool is_static() const {
973  return flags &1;
974  } bool is_global() const {
975  return flags &2;
976  }
977  };
978 
980  const char *name;
982  int director;
984  const char *constructor_doc;
987  const char **base_names;
989  };
990 
991  // octave_swig_type plays the role of both the shadow class and the class
992  // representation within Octave, since there is no support for classes.
993  //
994  // These should really be decoupled, with the class support added to Octave
995  // and the shadow class given by an m-file script. That would dramatically
996  // reduce the runtime complexity, and be more in line w/ other modules.
997 
998  class octave_swig_type:public octave_base_value {
999  struct cpp_ptr {
1000  void *ptr;
1002  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1003  }};
1004  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1005 
1007 
1008  const swig_type_info *construct_type; // type of special type object
1009  std::vector < type_ptr_pair > types; // our c++ base classes
1010  int own; // whether we call c++ destructors when we die
1011 
1012  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1013  typedef std::map < std::string, member_value_pair > member_map;
1014  member_map members;
1016 
1018  if (!type->clientdata)
1019  return 0;
1021  const swig_octave_member *m;
1022  for (m = c->members; m->name; ++m)
1023  if (m->name == name)
1024  return m;
1025  for (int j = 0; c->base_names[j]; ++j) {
1026  if (!c->base[j]) {
1027  if (!module)
1028  module = SWIG_GetModule(0);
1029  assert(module);
1030  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1031  }
1032  if (!c->base[j])
1033  return 0;
1034  if ((m = find_member(c->base[j], name)))
1035  return m;
1036  }
1037  return 0;
1038  }
1039 
1040  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1041  member_map::iterator it = members.find(name);
1042  if (it != members.end())
1043  return &it->second;
1044  const swig_octave_member *m;
1045  for (unsigned int j = 0; j < types.size(); ++j)
1046  if ((m = find_member(types[j].first, name)))
1047  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1048  if (!insert_if_not_found)
1049  return 0;
1050  return &members[name];
1051  }
1052 
1054  if (!base) {
1055  for (unsigned int j = 0; j < types.size(); ++j) {
1056  assert(types[j].first->clientdata);
1057  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1058  if (cj->name == name)
1059  return types[j].first;
1060  }
1061  return 0;
1062  }
1063  assert(base->clientdata);
1065  for (int j = 0; c->base_names[j]; ++j) {
1066  if (!c->base[j]) {
1067  if (!module)
1068  module = SWIG_GetModule(0);
1069  assert(module);
1070  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1071  }
1072  if (!c->base[j])
1073  return 0;
1074  assert(c->base[j]->clientdata);
1076  if (cj->name == name)
1077  return c->base[j];
1078  }
1079  return 0;
1080  }
1081 
1082  void load_members(const swig_octave_class* c,member_map& out) const {
1083  for (const swig_octave_member *m = c->members; m->name; ++m) {
1084  if (out.find(m->name) == out.end())
1085  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1086  }
1087  for (int j = 0; c->base_names[j]; ++j) {
1088  if (!c->base[j]) {
1089  if (!module)
1090  module = SWIG_GetModule(0);
1091  assert(module);
1092  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1093  }
1094  if (!c->base[j])
1095  continue;
1096  assert(c->base[j]->clientdata);
1097  const swig_octave_class *cj =
1098  (const swig_octave_class *) c->base[j]->clientdata;
1099  load_members(cj,out);
1100  }
1101  }
1102 
1103  void load_members(member_map& out) const {
1104  out=members;
1105  for (unsigned int j = 0; j < types.size(); ++j)
1106  if (types[j].first->clientdata)
1107  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1108  }
1109 
1110  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1111  if (m->second.is_defined())
1112  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1113  else if (m->first && m->first->method)
1114  return m->first->method(args, nargout);
1115  error("member not defined or not invocable");
1116  return octave_value_list();
1117  }
1118 
1119  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
1120  member_value_pair *m = find_member(symbol, false);
1121  if (!m || m->first->is_static() || m->first->is_global())
1122  return false;
1123  octave_value_list args;
1124  args.append(as_value());
1125  octave_value_list argout(member_invoke(m, args, 1));
1126  if (argout.length() < 1)
1127  return false;
1128  ret = argout(0);
1129  return true;
1130  }
1131 
1132  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
1133  member_value_pair *m = find_member(symbol, false);
1134  if (!m || m->first->is_static() || m->first->is_global())
1135  return false;
1136  octave_value_list args;
1137  args.append(as_value());
1138  args.append(make_value_hack(rhs));
1139  octave_value_list argout(member_invoke(m, args, 1));
1140  if (argout.length() < 1)
1141  return false;
1142  ret = argout(0);
1143  return true;
1144  }
1145 
1146  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
1147  member_value_pair *m = find_member(symbol, false);
1148  if (!m || m->first->is_static() || m->first->is_global())
1149  return false;
1150  octave_value_list args;
1151  args.append(as_value());
1152  args.append(rhs);
1153  octave_value_list argout(member_invoke(m, args, 1));
1154  if (argout.length() >= 1)
1155  ret = argout(0);
1156  return true;
1157  }
1158 
1159  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1160  if (m->second.is_defined())
1161  return m->second;
1162  else if (m->first) {
1163  if (m->first->get_method)
1164  return m->first->get_method(args, 1);
1165  else if (m->first->method)
1166  return octave_value(new octave_builtin(m->first->method));
1167  }
1168  error("undefined member");
1169  return octave_value_list();
1170  }
1171 
1172  static octave_value make_value_hack(const octave_base_value &x) {
1173  ((octave_swig_type &) x).count++;
1174  return octave_value((octave_base_value *) &x);
1175  }
1176 
1179  public:
1180 
1181  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1182  bool _always_static = false)
1183  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1184  always_static(_always_static) {
1185  if (_type || _ptr)
1186  types.push_back(std::make_pair(_type, _ptr));
1187 #ifdef SWIG_DIRECTORS
1188  if (_ptr) {
1189  Swig::Director *d = Swig::get_rtdir(_ptr);
1190  if (d)
1191  Swig::swig_director_set_self(d, this);
1192  }
1193 #endif
1194  }
1195 
1197  if (own) {
1198  ++count;
1199  for (unsigned int j = 0; j < types.size(); ++j) {
1200  if (!types[j].first || !types[j].first->clientdata)
1201  continue;
1202  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1203  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1204  c->destructor(as_value(), 0);
1205  }
1206  }
1207  }
1208 #ifdef SWIG_DIRECTORS
1209  for (unsigned int j = 0; j < types.size(); ++j)
1210  Swig::erase_rtdir(types[j].second.ptr);
1211 #endif
1212  }
1213 
1214  dim_vector dims(void) const {
1215  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1216 
1217  // Find the __dims__ method of this object
1218  member_value_pair *m = nc_this->find_member("__dims__", false);
1219 
1220  if (!m) return dim_vector(1,1);
1221 
1222  // Call the __dims__ method of this object
1223  octave_value_list inarg;
1224  inarg.append(nc_this->as_value());
1225  octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
1226 
1227  // __dims__ should return (at least) one output argument
1228  if (outarg.length() < 1) return dim_vector(1,1);
1229 
1230  octave_value & out = outarg(0);
1231 
1232  // Return value should be cell or matrix of integers
1233  if (out.is_cell()) {
1234  const Cell & c=out.cell_value();
1235  int ndim = c.rows();
1236  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1237 
1238  dim_vector d;
1239  d.resize(ndim < 2 ? 2 : ndim);
1240  d(0) = d(1) = 1;
1241 
1242  // Fill in dim_vector
1243  for (int k=0;k<ndim;k++) {
1244  const octave_value& obj = c(k);
1245  d.elem(k) = obj.int_value();
1246 
1247  // __dims__ should return a cell filled with integers
1248  if (error_state) return dim_vector(1,1);
1249  }
1250  return d;
1251  } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1252  if (out.rows()==1 || out.columns()==1) {
1253  Array<int> a = out.int_vector_value();
1254  if (error_state) return dim_vector(1,1);
1255  dim_vector d;
1256  d.resize(a.numel() < 2 ? 2 : a.numel());
1257  d(0) = d(1) = 1;
1258  for (int k=0;k<a.numel();k++) {
1259  d.elem(k) = a(k);
1260  }
1261  return d;
1262  } else {
1263  return dim_vector(1,1);
1264  }
1265  } else {
1266  return dim_vector(1,1);
1267  }
1268  }
1269 
1270  octave_value as_value() {
1271  ++count;
1272  return Swig::swig_value_ref(this);
1273  }
1274 
1275  void incref() {
1276  ++count;
1277  }
1278 
1279  void decref() {
1280  if (!--count)
1281  delete this;
1282  }
1283 
1284  long swig_this() const {
1285  if (!types.size())
1286  return (long) this;
1287  return (long) types[0].second.ptr;
1288  }
1289  const char* help_text() const {
1290  if (!types.size())
1291  return 0;
1292  if (!types[0].first->clientdata)
1293  return 0;
1294  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1295  return c->constructor_doc;
1296  }
1297 
1299  // * need some way to manually name subclasses.
1300  // * eg optional first arg to subclass(), or named_subclass()
1301  std::string ret;
1302  for (unsigned int j = 0; j < types.size(); ++j) {
1303  if (j)
1304  ret += "_";
1305  if (types[j].first->clientdata) {
1306  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1307  ret += c->name;
1308  } else
1309  ret += types[j].first->name;
1310  }
1311  return ret;
1312  }
1313 
1315  rhs.own = 0;
1316  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1317  assert(!rhs.types[j].second.destroyed);
1318 #ifdef SWIG_DIRECTORS
1319  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1320  if (d)
1321  Swig::swig_director_set_self(d, this);
1322 #endif
1323  }
1324  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1325  members.insert(rhs.members.begin(), rhs.members.end());
1326  rhs.types.clear();
1327  rhs.members.clear();
1328  }
1329 
1330  typedef member_map::const_iterator swig_member_const_iterator;
1331  swig_member_const_iterator swig_members_begin() { return members.begin(); }
1332  swig_member_const_iterator swig_members_end() { return members.end(); }
1333 
1334  void *cast(swig_type_info *type, int *_own, int flags) {
1335  if (_own)
1336  *_own = own;
1337  if (flags &SWIG_POINTER_DISOWN)
1338  own = 0;
1339  if (!type && types.size())
1340  return types[0].second.ptr;
1341  for (unsigned int j = 0; j < types.size(); ++j)
1342  if (type == types[j].first)
1343  return types[j].second.ptr;
1344  for (unsigned int j = 0; j < types.size(); ++j) {
1345  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1346  if (!tc)
1347  continue;
1348  int newmemory = 0;
1349  void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1350  assert(!newmemory); // newmemory handling not yet implemented
1351  return vptr;
1352  }
1353  return 0;
1354  }
1355 
1356  bool is_owned() const {
1357  return own;
1358  }
1359 
1360 #ifdef SWIG_DIRECTORS
1361  void director_destroyed(Swig::Director *d) {
1362  bool found = false;
1363  for (unsigned int j = 0; j < types.size(); ++j) {
1364  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1365  if (dj == d) {
1366  types[j].second.destroyed = true;
1367  found = true;
1368  }
1369  }
1370  assert(found);
1371  }
1372 #endif
1373 
1374  void assign(const std::string &name, const octave_value &ov) {
1375  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1376  }
1377 
1378  void assign(const std::string &name, const swig_octave_member *m) {
1379  members[name] = std::make_pair(m, octave_value());
1380  }
1381 
1382  octave_base_value *clone() const {
1383  // pass-by-value is probably not desired, and is harder;
1384  // requires calling copy constructors of contained types etc.
1385  assert(0);
1386  *(int *) 0 = 0;
1387  return 0;
1388  }
1389 
1390  octave_base_value *empty_clone() const {
1391  return new octave_swig_type();
1392  }
1393 
1394  bool is_defined() const {
1395  return true;
1396  }
1397 
1398  virtual bool is_map() const {
1399  return true;
1400  }
1401 
1402  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1403  octave_value_list ovl = subsref(ops, idx, 1);
1404  return ovl.length()? ovl(0) : octave_value();
1405  }
1406 
1407  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1408  assert(ops.size() > 0);
1409  assert(ops.size() == idx.size());
1410 
1411  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1412  int skip = 0;
1413  octave_value_list sub_ovl;
1414 
1415  // constructor invocation
1416  if (ops[skip] == '(' && construct_type) {
1417  assert(construct_type->clientdata);
1418  swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1419  if (!c->constructor) {
1420  error("cannot create instance");
1421  return octave_value_list();
1422  }
1423  octave_value_list args;
1424  if (c->director)
1425  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1426  args.append(*idx_it++);
1427  ++skip;
1428  sub_ovl = c->constructor(args, nargout);
1429  }
1430  // member dereference or invocation
1431  else if (ops[skip] == '.') {
1432  std::string subname;
1433  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1434  for (;;) {
1435  octave_value_list subname_ovl(*idx_it++);
1436  ++skip;
1437  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1438  subname = subname_ovl(0).string_value();
1439 
1440  const swig_type_info *next_base = find_base(subname, base);
1441  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1442  break;
1443  base = next_base;
1444  }
1445 
1446  member_value_pair tmp, *m = &tmp;
1447  if (!base || !(m->first = find_member(base, subname)))
1448  m = find_member(subname, false);
1449  if (!m) {
1450  error("member not found");
1451  return octave_value_list();
1452  }
1453 
1454  octave_value_list args;
1455  if (!always_static &&
1456  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1457  args.append(as_value());
1458  if (skip < (int) ops.size() && ops[skip] == '(' &&
1459  ((m->first && m->first->method) || m->second.is_function() ||
1460  m->second.is_function_handle())) {
1461  args.append(*idx_it++);
1462  ++skip;
1463  sub_ovl = member_invoke(m, args, nargout);
1464  } else {
1465  sub_ovl = member_deref(m, args);
1466  }
1467  }
1468  // index operator
1469  else {
1470  if (ops[skip] == '(' || ops[skip] == '{') {
1471  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1472  octave_value_list args;
1473  args.append(*idx_it++);
1474  ++skip;
1475  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1476  error("error evaluating index operator");
1477  return octave_value_list();
1478  }
1479  } else {
1480  error("unsupported subsref");
1481  return octave_value_list();
1482  }
1483  }
1484 
1485  if (skip >= (int) ops.size())
1486  return sub_ovl;
1487  if (sub_ovl.length() < 1) {
1488  error("bad subs ref");
1489  return octave_value_list();
1490  }
1491  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1492  }
1493 
1494  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1495  assert(ops.size() > 0);
1496  assert(ops.size() == idx.size());
1497 
1498  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1499  int skip = 0;
1500 
1501  if (ops.size() > 1) {
1502  std::list < octave_value_list >::const_iterator last = idx.end();
1503  --last;
1504  std::list < octave_value_list > next_idx(idx.begin(), last);
1505  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1506  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1507  }
1508 
1509  else if (ops[skip] == '(' || ops[skip] == '{') {
1510  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1511  member_value_pair *m = find_member(op_name, false);
1512  if (m) {
1513  octave_value_list args;
1514  args.append(as_value());
1515  args.append(*idx_it);
1516  args.append(rhs);
1517  member_invoke(m, args, 1);
1518  } else
1519  error("%s member not found", op_name);
1520  }
1521 
1522  else if (ops[skip] == '.') {
1523  octave_value_list subname_ovl(*idx_it++);
1524  ++skip;
1525  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1526  std::string subname = subname_ovl(0).string_value();
1527 
1528  member_value_pair *m = find_member(subname, true);
1529  if (!m->first || !m->first->set_method) {
1530  m->first = 0;
1531  m->second = rhs;
1532  } else if (m->first->set_method) {
1533  octave_value_list args;
1534  if (!m->first->is_static() && !m->first->is_global())
1535  args.append(as_value());
1536  args.append(rhs);
1537  m->first->set_method(args, 1);
1538  } else
1539  error("member not assignable");
1540  } else
1541  error("unsupported subsasgn");
1542 
1543  return as_value();
1544  }
1545 
1546  virtual bool is_object() const {
1547  return true;
1548  }
1549 
1550  virtual bool is_string() const {
1551  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1552  return !!nc_this->find_member("__str__", false);
1553  }
1554 
1555  virtual std::string string_value(bool force = false) const {
1556  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1557  member_value_pair *m = nc_this->find_member("__str__", false);
1558  if (!m) {
1559  error("__str__ method not defined");
1560  return std::string();
1561  }
1562  octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
1563  if (outarg.length() < 1 || !outarg(0).is_string()) {
1564  error("__str__ method did not return a string");
1565  return std::string();
1566  }
1567  return outarg(0).string_value();
1568  }
1569 
1570 #if SWIG_OCTAVE_PREREQ(3,3,52)
1571  virtual octave_map map_value() const {
1572  return octave_map();
1573  }
1574 #else
1575  virtual Octave_map map_value() const {
1576  return Octave_map();
1577  }
1578 #endif
1579 
1580  virtual string_vector map_keys() const {
1581  member_map tmp;
1582  load_members(tmp);
1583 
1584  string_vector keys(tmp.size());
1585  int k = 0;
1586  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1587  keys(k++) = it->first;
1588 
1589  return keys;
1590  }
1591 
1592  virtual bool save_ascii (std::ostream& os) {
1593  return true;
1594  }
1595 
1596  virtual bool load_ascii (std::istream& is) {
1597  return true;
1598  }
1599 
1600  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1601  return true;
1602  }
1603 
1604  virtual bool load_binary (std::istream& is, bool swap,
1605  oct_mach_info::float_format fmt) {
1606  return true;
1607  }
1608 
1609 #if defined (HAVE_HDF5)
1610  virtual bool
1611  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1612  return true;
1613  }
1614 
1615  virtual bool
1616  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1617  return true;
1618  }
1619 #endif
1620 
1621  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1622  return string_value();
1623  }
1624 
1625  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1626  return string_value();
1627  }
1628 
1629  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1630  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1631  // (rather than any module namespace).
1632 
1633  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1634  if (!fcn)
1635  return false;
1636  ret = fcn->do_multi_index_op(1, args)(0);
1637  return true;
1638  }
1639 
1640  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1642  assert(ost);
1643 
1644  octave_value ret;
1645  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1646  return ret;
1647  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1648  octave_value_list args;
1649  args.append(make_value_hack(x));
1650  if (dispatch_global_op(symbol, args, ret))
1651  return ret;
1652 
1653  error("could not dispatch unary operator");
1654  return octave_value();
1655  }
1656 
1657  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1658  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1659  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1660 
1661  octave_value ret;
1662  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1663  return ret;
1664  if (rhs_ost) {
1665  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1666  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1667  return ret;
1668  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1669  return ret;
1670  }
1671  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1672  return ret;
1673  }
1674 
1675  std::string symbol;
1676  octave_value_list args;
1677  args.append(make_value_hack(lhs));
1678  args.append(make_value_hack(rhs));
1679 
1680  symbol = SWIG_op_prefix;
1681  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1682  symbol += "_";
1683  symbol += op_name;
1684  symbol += "_";
1685  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1686  if (dispatch_global_op(symbol, args, ret))
1687  return ret;
1688 
1689  symbol = SWIG_op_prefix;
1690  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1691  symbol += "_";
1692  symbol += op_name;
1693  symbol += "_";
1694  symbol += "any";
1695  if (dispatch_global_op(symbol, args, ret))
1696  return ret;
1697 
1698  symbol = SWIG_op_prefix;
1699  symbol += "any";
1700  symbol += "_";
1701  symbol += op_name;
1702  symbol += "_";
1703  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1704  if (dispatch_global_op(symbol, args, ret))
1705  return ret;
1706 
1707  error("could not dispatch binary operator");
1708  return octave_value();
1709  }
1710 
1711  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1712  if (is_string()) {
1713  os << string_value();
1714  return;
1715  }
1716 
1717  member_map tmp;
1718  load_members(tmp);
1719 
1720  indent(os);
1721  os << "{"; newline(os);
1722  increment_indent_level();
1723  for (unsigned int j = 0; j < types.size(); ++j) {
1724  indent(os);
1725  if (types[j].first->clientdata) {
1726  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1727  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1728  } else {
1729  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1730  }
1731  }
1732  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1733  indent(os);
1734  if (it->second.first) {
1735  const char *objtype = it->second.first->method ? "method" : "variable";
1736  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1737  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1738  assert(it->second.first->name == it->first);
1739  } else {
1740  os << it->first; newline(os);
1741  }
1742  }
1743  decrement_indent_level();
1744  indent(os);
1745  os << "}"; newline(os);
1746  }
1747  };
1748 
1749  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1750  // will call clone() via make_unique() if there is more than one outstanding
1751  // reference to the lhs, and forces the clone's reference count to 1
1752  // (so you can't just increment your own count and return this).
1753  //
1754  // One way to fix this (without modifying Octave) is to add a level of
1755  // indirection such that clone copies ref-counted pointer and we keep
1756  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1757  //
1758  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1759  // might be nice.
1760 
1761  class octave_swig_ref:public octave_base_value {
1763  public:
1765  :ptr(_ptr) { }
1766 
1768  { if (ptr) ptr->decref(); }
1769 
1771  { return ptr; }
1772 
1773  octave_base_value *clone() const
1774  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1775 
1776  octave_base_value *empty_clone() const
1777  { return new octave_swig_ref(0); }
1778 
1779  dim_vector dims(void) const
1780  { return ptr->dims(); }
1781 
1782  bool is_defined() const
1783  { return ptr->is_defined(); }
1784 
1785  virtual bool is_map() const
1786  { return ptr->is_map(); }
1787 
1788  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1789  { return ptr->subsref(ops, idx); }
1790 
1791  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1792  { return ptr->subsref(ops, idx, nargout); }
1793 
1794  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1795  { return ptr->subsasgn(ops, idx, rhs); }
1796 
1797  virtual bool is_object() const
1798  { return ptr->is_object(); }
1799 
1800  virtual bool is_string() const
1801  { return ptr->is_string(); }
1802 
1803  virtual std::string string_value(bool force = false) const
1804  { return ptr->string_value(force); }
1805 
1806 #if SWIG_OCTAVE_PREREQ(3,3,52)
1807  virtual octave_map map_value() const
1808  { return ptr->map_value(); }
1809 #else
1810  virtual Octave_map map_value() const
1811  { return ptr->map_value(); }
1812 #endif
1813 
1814  virtual string_vector map_keys() const
1815  { return ptr->map_keys(); }
1816 
1817  virtual bool save_ascii (std::ostream& os)
1818  { return ptr->save_ascii(os); }
1819 
1820  virtual bool load_ascii (std::istream& is)
1821  { return ptr->load_ascii(is); }
1822 
1823  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
1824  { return ptr->save_binary(os, save_as_floats); }
1825 
1826  virtual bool load_binary (std::istream& is, bool swap,
1827  oct_mach_info::float_format fmt)
1828  { return ptr->load_binary(is, swap, fmt); }
1829 
1830 #if defined (HAVE_HDF5)
1831  virtual bool
1832  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
1833  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
1834 
1835  virtual bool
1836  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
1837  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1838 #endif
1839 
1840  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
1841  { return ptr->convert_to_str(pad, force, type); }
1842 
1843  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
1844  { return ptr->convert_to_str_internal(pad, force, type); }
1845 
1846  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1847  { return ptr->print(os, pr_as_read_syntax); }
1848 
1849  private:
1852  };
1854  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
1855 
1856  class octave_swig_packed:public octave_base_value {
1858  std::vector < char > buf;
1859  public:
1860 
1861  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
1862  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1863  }
1864 
1865  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
1866  if (outtype && outtype != type)
1867  return false;
1868  assert(sz <= buf.size());
1869  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
1870  return true;
1871  }
1872 
1873  octave_base_value *clone() const {
1874  return new octave_swig_packed(*this);
1875  }
1876 
1877  octave_base_value *empty_clone() const {
1878  return new octave_swig_packed();
1879  }
1880 
1881  bool is_defined() const {
1882  return true;
1883  }
1884 
1885  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1886  indent(os);
1887  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
1888  }
1889 
1890 
1891  virtual bool save_ascii (std::ostream& os) {
1892  return true;
1893  }
1894 
1895  virtual bool load_ascii (std::istream& is) {
1896  return true;
1897  }
1898 
1899  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1900  return true;
1901  }
1902 
1903  virtual bool load_binary (std::istream& is, bool swap,
1904  oct_mach_info::float_format fmt) {
1905  return true;
1906  }
1907 
1908 #if defined (HAVE_HDF5)
1909  virtual bool
1910  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1911  return true;
1912  }
1913 
1914  virtual bool
1915  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1916  return true;
1917  }
1918 #endif
1919 
1920  private:
1923  };
1925  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
1926 
1927  static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
1928  error("attempt to set immutable member variable");
1929  return octave_value_list();
1930  }
1931 
1933  const octave_value_list &ovl;
1934  int j;
1935 
1936  octave_value_ref(const octave_value_list &_ovl, int _j)
1937  :ovl(_ovl), j(_j) { }
1938 
1939  operator octave_value() const {
1940  return ovl(j);
1941  }
1942 
1943  octave_value operator*() const {
1944  return ovl(j);
1945  }
1946  };
1947 
1948 
1949 namespace Swig {
1950 
1951  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
1952  return new octave_swig_ref(ost);
1953  }
1954 
1956  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1957  ov = ov.cell_value()(0);
1958  return swig_value_deref(*ov.internal_rep());
1959  }
1960 
1961  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
1962  if (ov.type_id() != octave_swig_ref::static_type_id())
1963  return 0;
1964  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
1965  return osr->get_ptr();
1966  }
1967 
1968 }
1969 
1970 
1971 #define swig_unary_op(name) \
1972 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1973  return octave_swig_type::dispatch_unary_op(x,#name); \
1974 }
1975 #define swig_binary_op(name) \
1976 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1977  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1978 }
1979 #define swigreg_unary_op(name) \
1980 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1981 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1982 #define swigreg_binary_op(name) \
1983 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1984 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1985 
1986  swig_unary_op(not);
1987  swig_unary_op(uplus);
1988  swig_unary_op(uminus);
1989  swig_unary_op(transpose);
1990  swig_unary_op(hermitian);
1991  swig_unary_op(incr);
1992  swig_unary_op(decr);
1993 
1994  swig_binary_op(add);
1995  swig_binary_op(sub);
1996  swig_binary_op(mul);
1997  swig_binary_op(div);
1998  swig_binary_op(pow);
1999  swig_binary_op(ldiv);
2000  swig_binary_op(lshift);
2001  swig_binary_op(rshift);
2002  swig_binary_op(lt);
2003  swig_binary_op(le);
2004  swig_binary_op(eq);
2005  swig_binary_op(ge);
2006  swig_binary_op(gt);
2007  swig_binary_op(ne);
2008  swig_binary_op(el_mul);
2009  swig_binary_op(el_div);
2010  swig_binary_op(el_pow);
2011  swig_binary_op(el_ldiv);
2012  swig_binary_op(el_and);
2013  swig_binary_op(el_or);
2014 
2016  swigreg_unary_op(not);
2017  swigreg_unary_op(uplus);
2018  swigreg_unary_op(uminus);
2019  swigreg_unary_op(transpose);
2020  swigreg_unary_op(hermitian);
2021  swigreg_unary_op(incr);
2022  swigreg_unary_op(decr);
2023  }
2024  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2025  swigreg_binary_op(add);
2026  swigreg_binary_op(sub);
2027  swigreg_binary_op(mul);
2028  swigreg_binary_op(div);
2029  swigreg_binary_op(pow);
2030  swigreg_binary_op(ldiv);
2031  swigreg_binary_op(lshift);
2032  swigreg_binary_op(rshift);
2033  swigreg_binary_op(lt);
2034  swigreg_binary_op(le);
2035  swigreg_binary_op(eq);
2036  swigreg_binary_op(ge);
2037  swigreg_binary_op(gt);
2038  swigreg_binary_op(ne);
2039  swigreg_binary_op(el_mul);
2040  swigreg_binary_op(el_div);
2041  swigreg_binary_op(el_pow);
2042  swigreg_binary_op(el_ldiv);
2043  swigreg_binary_op(el_and);
2044  swigreg_binary_op(el_or);
2045  }
2047  // here we assume that tid are conseq integers increasing from zero, and
2048  // that our tid is the last one. might be better to have explicit string
2049  // list of types we should bind to, and use lookup_type to resolve their tid.
2050 
2051  SWIG_InstallUnaryOps(tid);
2052  SWIG_InstallBinaryOps(tid, tid);
2053  for (int j = 0; j < tid; ++j) {
2054  SWIG_InstallBinaryOps(j, tid);
2055  SWIG_InstallBinaryOps(tid, j);
2056  }
2057  }
2058 
2059 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2060  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2061 
2062 #ifdef SWIG_DIRECTORS
2063  Swig::Director *d = Swig::get_rtdir(ptr);
2064  if (d && Swig::swig_director_get_self(d))
2065  return Swig::swig_director_get_self(d)->as_value();
2066 #endif
2067  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2068 }
2069 
2070 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2071  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2072  ov = ov.cell_value()(0);
2073  if (!ov.is_defined() ||
2074  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2075  if (ptr)
2076  *ptr = 0;
2077  return SWIG_OK;
2078  }
2079  if (ov.type_id() != octave_swig_ref::static_type_id())
2080  return SWIG_ERROR;
2081  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2082  octave_swig_type *ost = osr->get_ptr();
2083  void *vptr = ost->cast(type, own, flags);
2084  if (!vptr)
2085  return SWIG_ERROR;
2086  if (ptr)
2087  *ptr = vptr;
2088  return SWIG_OK;
2089 }
2090 
2091 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2092  return new octave_swig_packed(type, (char *) ptr, sz);
2093 }
2094 
2095 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2096  if (!ov.is_defined())
2097  return SWIG_ERROR;
2098  if (ov.type_id() != octave_swig_packed::static_type_id())
2099  return SWIG_ERROR;
2100  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2101  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2102 }
2103 
2104 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2105  module_ns->assign(name, ov);
2106 }
2107 
2109  return get_global_value(name, true);
2110 }
2111 
2112 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2113  set_global_value(name, value);
2114 }
2115 
2117 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2118  link_to_global_variable(curr_sym_tab->lookup(name, true));
2119 #else
2120 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2121  symbol_table::varref(name);
2122 #endif
2123  symbol_table::mark_global(name);
2124 #endif
2125 }
2126 
2128  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2129  if (!ov.is_defined() ||
2130  ov.type_id() != octave_swig_packed::static_type_id())
2131  return 0;
2132  const octave_swig_packed* osp =
2133  static_cast < const octave_swig_packed *> (ov.internal_rep());
2134  swig_module_info *pointer = 0;
2135  osp->copy(0, &pointer, sizeof(swig_module_info *));
2136  return pointer;
2137 }
2138 
2139 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2140  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2142 }
2143 
2144 
2145 
2146 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2147 
2148 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2149 
2150 
2151 
2152 /* -------- TYPES TABLE (BEGIN) -------- */
2153 
2154 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2155 #define SWIGTYPE_p_char swig_types[1]
2156 #define SWIGTYPE_p_double swig_types[2]
2157 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2158 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2159 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2160 #define SWIGTYPE_p_int swig_types[6]
2161 #define SWIGTYPE_p_p_char swig_types[7]
2162 #define SWIGTYPE_p_unsigned_int swig_types[8]
2164 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2165 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2166 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2167 
2168 /* -------- TYPES TABLE (END) -------- */
2169 
2170 
2171 #define SWIGVERSION 0x020012
2172 #define SWIG_VERSION SWIGVERSION
2173 
2174 
2175 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2176 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2177 
2178 
2179 #include <stdexcept>
2180 
2181 
2182 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2183 #undef PACKAGE
2184 #undef VERSION
2185 
2186 #include "plplotP.h"
2187 
2188 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2189 #ifdef OCTAVE_EXPORT
2190  #if defined ( __GNUC__ ) && __GNUC__ > 3
2191  #undef OCTAVE_EXPORT
2192  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2193  #endif
2194 #endif
2195 
2196 
2197 
2198 // I hate global variables but this is the best way I can think of
2199 // to manage consistency checking among function arguments.
2200  static PLINT Alen = 0;
2201  static PLINT Xlen = 0, Ylen = 0;
2202 
2203 
2204 // Convenience functions copied from matwrap-based approach (currently
2205 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2206 // tricky scalar case and also adopted so that the resulting
2207 // swig-generated source code will look similar to the matwrap-generated
2208 // source code.
2209 
2210  inline int max( int a, int b )
2211  {
2212  return a >= b ? a : b;
2213  }
2214  inline int min( int a, int b )
2215  {
2216  return a >= b ? a : b;
2217  }
2218 
2219 //
2220 // Function to get the total length (rows*columns) of an octave object of
2221 // arbitrary type.
2222 // Arguments:
2223 // 1) The octave object.
2224 //
2225 // If the object is a scalar, the array length is 1.
2226 //
2227  static int
2228  _arraylen( const octave_value &o_obj )
2229  {
2230  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2231  // max is necessary because sometimes
2232  // rows() or columns() return -1 or 0 for
2233  // scalars.
2234  }
2235 
2236 //
2237 // Function to get the number of dimensions of an object.
2238 //
2239  static int
2240  _n_dims( const octave_value &o_obj )
2241  {
2242  if ( max( o_obj.columns(), 1 ) > 1 )
2243  return 2;
2244  // max is necessary because sometimes
2245  // rows() or columns() return -1 or 0 for
2246  // scalars.
2247  else if ( max( o_obj.rows(), 1 ) > 1 )
2248  return 1;
2249  else
2250  return 0;
2251  }
2252 
2253 //
2254 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2255 //
2256  static inline int
2257  _dim( const octave_value &o_obj, int dim_idx )
2258  {
2259  if ( dim_idx == 0 )
2260  return max( o_obj.rows(), 0 );
2261  // max is necessary because sometimes
2262  // rows() or columns() return -1 or 0 for
2263  // scalars.
2264  else if ( dim_idx == 1 )
2265  return max( o_obj.columns(), 0 );
2266  else
2267  return 1;
2268  }
2269 
2270 //
2271 // The following function converts an array of doubles into some other
2272 // numeric type. Arguments:
2273 // 1) Where to store the result. The type is determined from the type of
2274 // this pointer.
2275 // 2) A vector of doubles to convert.
2276 // 3) The number of doubles.
2277 //
2278  template <class FLOAT>
2279  static inline void
2280  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2281  {
2282  while ( n_el-- > 0 )
2283  *out_arr++ = (FLOAT) ( *in_arr++ );
2284  }
2285 
2286  template void _cvt_double_to( int *, double *, unsigned );
2287  template void _cvt_double_to( unsigned *, double *, unsigned );
2288  template void _cvt_double_to( long *, double *, unsigned );
2289  template void _cvt_double_to( unsigned long *, double *, unsigned );
2290  template void _cvt_double_to( short *, double *, unsigned );
2291  template void _cvt_double_to( unsigned short *, double *, unsigned );
2292  template void _cvt_double_to( float *, double *, unsigned );
2293  // Instantiate our templates. Octave uses
2294  // manual template instantiation.
2295 
2296 //
2297 // Convert an array of some other type into an array of doubles. Arguments:
2298 // 1) The array of objects of other type.
2299 // 2) The output array of doubles.
2300 // 3) The number of elements to convert.
2301 //
2302  template <class FLOAT>
2303  static inline void
2304  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2305  {
2306  while ( n_el-- > 0 )
2307  *d_arr++ = double(*arr++);
2308  }
2309 
2310  template void _cvt_to_double( int *, double *, unsigned );
2311  template void _cvt_to_double( unsigned *, double *, unsigned );
2312  template void _cvt_to_double( long *, double *, unsigned );
2313  template void _cvt_to_double( unsigned long *, double *, unsigned );
2314  template void _cvt_to_double( short *, double *, unsigned );
2315  template void _cvt_to_double( unsigned short *, double *, unsigned );
2316  template void _cvt_to_double( float *, double *, unsigned );
2317  // Instantiate our templates. Octave uses
2318  // manual template instantiation.
2319 
2320 
2321  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2322  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2323  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2324  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2325  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2327  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2328 
2329 
2330 #include <iostream>
2331 
2332  octave_function *fcnMapForm;
2334 
2335  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2336  {
2337  octave_idx_type i;
2338  octave_value_list functionArguments;
2339  octave_value_list retval;
2340 
2341  Matrix xin( n, 1 );
2342  Matrix yin( n, 1 );
2343  Matrix xout;
2344  Matrix yout;
2345 
2346  for ( i = 0; i < n; i++ )
2347  {
2348  xin( i, 0 ) = x[i];
2349  yin( i, 0 ) = y[i];
2350  }
2351 
2352  functionArguments( 0 ) = xin;
2353  functionArguments( 1 ) = yin;
2354 
2355  if ( fcnMapForm != NULL )
2356  retval = feval( fcnMapForm, functionArguments, 1 );
2357  else
2358  retval = feval( nameMapForm, functionArguments, 1 );
2359 
2360 
2361  if ( retval.length() >= 2 )
2362  {
2363  xout = retval( 0 ).matrix_value();
2364  yout = retval( 1 ).matrix_value();
2365 
2366  for ( i = 0; i < n; i++ )
2367  {
2368  x[i] = xout( i, 0 );
2369  y[i] = yout( i, 0 );
2370  }
2371  }
2372  }
2373 
2374 
2375  octave_function *fcnLabelFunc;
2377 
2378  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2379  {
2380  int i;
2381  octave_value_list functionArguments;
2382  octave_value_list retval;
2383 
2384  Matrix inAxis( 1, 1 );
2385  Matrix inValue( 1, 1 );
2386  inAxis( 0, 0 ) = axis;
2387  inValue( 0, 0 ) = value;
2388 
2389  functionArguments( 0 ) = inAxis;
2390  functionArguments( 1 ) = inValue;
2391 
2392  if ( fcnLabelFunc != NULL )
2393  retval = feval( fcnLabelFunc, functionArguments, 1 );
2394  else
2395  retval = feval( nameLabelFunc, functionArguments, 1 );
2396 
2397  strncpy( label, retval( 0 ).string_value().c_str(), length );
2398  }
2399 
2400 
2401  octave_function *fcnCoordTrans;
2403 
2404  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2405  {
2406  octave_idx_type i;
2407  octave_value_list functionArguments;
2408  octave_value_list retval;
2409 
2410  Matrix xin( 1, 1 );
2411  Matrix yin( 1, 1 );
2412  Matrix xout;
2413  Matrix yout;
2414 
2415  xin( 0, 0 ) = x;
2416  yin( 0, 0 ) = y;
2417 
2418  functionArguments( 0 ) = xin;
2419  functionArguments( 1 ) = yin;
2420 
2421  if ( fcnCoordTrans != NULL )
2422  retval = feval( fcnCoordTrans, functionArguments, 1 );
2423  else
2424  retval = feval( nameCoordTrans, functionArguments, 1 );
2425 
2426 
2427  if ( retval.length() >= 2 )
2428  {
2429  xout = retval( 0 ).matrix_value();
2430  yout = retval( 1 ).matrix_value();
2431 
2432  *xt = xout( 0, 0 );
2433  *yt = yout( 0, 0 );
2434  }
2435  }
2436 
2437 
2438  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2439  {
2440  PLINT i;
2441  printf( "nlegend =%d\n", nlegend );
2442  for ( i = 0; i < nlegend; i++ )
2443  {
2444  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2445  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2446  printf( "text[%d] =%s\n", i, text[i] );
2447  }
2448  }
2449 
2450 
2451 #include <limits.h>
2452 #if !defined(SWIG_NO_LLONG_MAX)
2453 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2454 # define LLONG_MAX __LONG_LONG_MAX__
2455 # define LLONG_MIN (-LLONG_MAX - 1LL)
2456 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2457 # endif
2458 #endif
2459 
2460 
2461  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2462  {
2463  if (!ov.is_scalar_type())
2464  return SWIG_TypeError;
2465  if (ov.is_complex_scalar())
2466  return SWIG_TypeError;
2467  if (ov.is_double_type()||ov.is_single_type()) {
2468  double v=ov.double_value();
2469  if (v!=floor(v))
2470  return SWIG_TypeError;
2471  }
2472  if (val)
2473  *val = ov.long_value();
2474  return SWIG_OK;
2475  }
2476 
2477 
2478 SWIGINTERN int
2479 SWIG_AsVal_int (octave_value obj, int *val)
2480 {
2481  long v;
2482  int res = SWIG_AsVal_long (obj, &v);
2483  if (SWIG_IsOK(res)) {
2484  if ((v < INT_MIN || v > INT_MAX)) {
2485  return SWIG_OverflowError;
2486  } else {
2487  if (val) *val = (int)(v);
2488  }
2489  }
2490  return res;
2491 }
2492 
2493 
2494  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 )
2495  {
2496  PLGraphicsIn gin;
2497  int status; status = plGetCursor( &gin );
2498  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2499  strncpy( string, gin.string, PL_MAXKEY - 1 );
2500  string[PL_MAXKEY - 1] = '\0';
2501 
2502  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2503  return status;
2504  }
2505 
2506 
2507 SWIGINTERN int
2508 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2509 {
2510  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2511  ov = ov.cell_value()(0);
2512  if (!ov.is_string())
2513  return SWIG_TypeError;
2514 
2515  std::string str=ov.string_value();
2516  size_t len=str.size();
2517  char* cstr=(char*)str.c_str();
2518  if (alloc) {
2519  *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2520  *alloc = SWIG_NEWOBJ;
2521  } else if (cptr)
2522  *cptr = cstr;
2523  if (psize)
2524  *psize = len + 1;
2525  return SWIG_OK;
2526 }
2527 
2528 
2529 
2530 
2531 
2533  {
2534  return octave_value(value);
2535  }
2536 
2537 
2538 SWIGINTERNINLINE octave_value
2540 {
2541  return SWIG_From_long (value);
2542 }
2543 
2544 
2546  {
2547  return octave_value(value);
2548  }
2549 
2550 
2551 // Translates relative device coordinates to world coordinates.
2552  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2553  {
2554  PLGraphicsIn gin;
2555  int st;
2556  gin.dX = x_in; gin.dY = y_in;
2557  st = plTranslateCursor( &gin );
2558  *x = gin.wX; *y = gin.wY;
2559  return st;
2560  }
2561 
2562 
2563  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2564  {
2565  if (!ov.is_scalar_type())
2566  return SWIG_TypeError;
2567  if (ov.is_complex_scalar())
2568  return SWIG_TypeError;
2569  if (val)
2570  *val = ov.double_value();
2571  return SWIG_OK;
2572  }
2573 
2574 
2575 // Create 1d stripchart
2576 
2577  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2578  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2579  PLFLT xlpos, PLFLT ylpos,
2580  PLBOOL y_ascl, PLBOOL acc,
2581  PLINT colbox, PLINT collab,
2582  const PLINT *colline, const PLINT *styline,
2583  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2584  const char *labx, const char *laby, const char *labtop )
2585  {
2586  const char *legline[4];
2587  legline[0] = legline1; legline[1] = legline2;
2588  legline[2] = legline3; legline[3] = legline4;
2589  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2590  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2591  labx, laby, labtop );
2592  }
2593 
2594 
2595 // One more hack. As it is not possible (and would not be desirable) to pass
2596 // an Octave function to plcont(), I have defined three plcont():
2597 // plcont uses a defined here xform()
2598 // plcont0 uses pltr0()
2599 // plcont1 uses pltr1()
2600 // plcont2 uses pltr2()
2601 // plcont2p uses pltr2p()
2602 //
2603 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2604 // f2c, which is a #define that does the necessary conversion.
2605 //
2606 
2607  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2608  {
2609  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2610  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2611  }
2612 
2613 // convert from Fortran like arrays (one vector), to C like 2D arrays
2614 
2615 #define f2c( f, ff, nx, ny ) \
2616  PLFLT * *ff; \
2617  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2618  for ( int i = 0; i < nx; i++ ) { \
2619  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2620  for ( int j = 0; j < ny; j++ ) \
2621  *( ff[i] + j ) = *( f + nx * j + i );}
2622 
2623 // simpler plcont() for use with xform()
2624 
2625  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2626  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2627  {
2628  f2c( f, ff, nx, ny );
2629  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2630  }
2631 
2632 // plcont() for use with pltr0() NOT TESTED
2633 
2634  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2635  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2636  {
2637  f2c( f, ff, nx, ny );
2638  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2639  }
2640 
2641 // plcont() for use with pltr1()
2642 
2643  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2644  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2645  {
2646  PLcGrid grid1;
2647  grid1.nx = nx; grid1.ny = ny;
2648  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2649  f2c( f, ff, nx, ny );
2650  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2651  }
2652 
2653 // plcont() for use with pltr2()
2654  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2655  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2656  {
2657  PLcGrid2 grid2;
2658  f2c( xg, xgg, nx, ny );
2659  f2c( yg, ygg, nx, ny );
2660  grid2.nx = nx; grid2.ny = ny;
2661  grid2.xg = xgg; grid2.yg = ygg;
2662  f2c( f, ff, nx, ny );
2663  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2664  }
2665 
2666 // plcont() for use with pltr2p()
2667 
2668  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2669  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2670  {
2671  PLcGrid2 grid2;
2672  f2c( xg, xgg, nx, ny );
2673  f2c( yg, ygg, nx, ny );
2674  grid2.nx = nx; grid2.ny = ny;
2675  grid2.xg = xgg; grid2.yg = ygg;
2676  f2c( f, ff, nx, ny );
2677  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2678  }
2679 
2680 
2681  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2682  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2683  PLFLT *zg, int type, PLFLT data )
2684  {
2685  f2c( zg, zgg, nptsx, nptsy );
2686  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2687  for ( int i = 0; i < nptsx; i++ )
2688  for ( int j = 0; j < nptsy; j++ )
2689  *( zg + nptsx * j + i ) = zgg[i][j];
2690  }
2691 
2692 
2693 // Plots a mesh representation of the function z[x][y].
2694 
2695  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2696  {
2697  f2c( z, zz, nx, ny );
2698  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
2699  }
2700 
2701 // Plots a mesh representation of the function z[x][y] with contour
2702 
2703  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2704  {
2705  f2c( z, zz, nx, ny );
2706  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2707  }
2708 
2709 
2710 // Plots a 3-d representation of the function z[x][y].
2711  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2712  PLINT nx, PLINT ny, PLINT opt, PLINT side )
2713  {
2714  f2c( z, zz, nx, ny );
2715  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
2716  }
2717 
2718 // Plots a 3-d representation of the function z[x][y] with contour
2719  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2720  PLINT nx, PLINT ny, PLINT opt,
2721  const PLFLT *clevel, PLINT nlevel )
2722  {
2723  f2c( z, zz, nx, ny );
2724  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2725  }
2726 // Plots a 3-d representation of the function z[x][y] with contour with y
2727 // index limits
2728  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
2729  PLINT nx, PLINT ny, PLINT opt,
2730  const PLFLT * clevel, PLINT nlevel,
2731  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
2732  {
2733  f2c( z, zz, nx, ny );
2734  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2735  indexxmin, indexxmax, indexymin, indexymax );
2736  }
2737 
2738 
2739  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2740  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2741  {
2742  f2c( z, zz, nx, ny );
2743  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2744  }
2745 
2746  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
2747  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
2748  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
2749  {
2750  f2c( z, zz, nx, ny );
2751  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
2752  indexxmin, indexxmax, indexymin, indexymax );
2753  }
2754 
2755 
2756 // The same as in plcont. I have hardcoded the first function pointer
2757 // to plfill(). The second function pointer will use the same convention
2758 // as in plcont().
2759 //
2760 
2761 // the simpler plshade()
2762  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
2763  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2764  PLFLT shade_min, PLFLT shade_max,
2765  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2766  PLINT min_color, PLINT min_width,
2767  PLINT max_color, PLINT max_width,
2768  PLINT rectangular, PLFLT *tr )
2769  {
2770  f2c( a, aa, nx, ny );
2771  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2772  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2773  min_color, min_width, max_color, max_width,
2774  plfill, rectangular, xform, tr );
2775  }
2776 
2777 // plshade() for use with pltr1
2778  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2779  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2780  PLFLT shade_min, PLFLT shade_max,
2781  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2782  PLINT min_color, PLINT min_width,
2783  PLINT max_color, PLINT max_width,
2784  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2785  {
2786  PLcGrid grid1;
2787  grid1.nx = nx; grid1.ny = ny;
2788  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2789  f2c( a, aa, nx, ny );
2790  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2791  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2792  min_color, min_width, max_color, max_width,
2793  plfill, rectangular, pltr1, &grid1 );
2794  }
2795 
2796 // plshade() for use with pltr2
2797  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2798  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2799  PLFLT shade_min, PLFLT shade_max,
2800  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2801  PLINT min_color, PLINT min_width,
2802  PLINT max_color, PLINT max_width,
2803  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2804  {
2805  PLcGrid2 grid2;
2806  f2c( xg, xgg, nx, ny );
2807  f2c( yg, ygg, nx, ny );
2808  grid2.nx = nx; grid2.ny = ny;
2809  grid2.xg = xgg; grid2.yg = ygg;
2810  f2c( a, aa, nx, ny );
2811  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2812  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2813  min_color, min_width, max_color, max_width,
2814  plfill, rectangular, pltr2, &grid2 );
2815  }
2816 
2817 
2818 
2819  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
2820  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2821  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2822  PLINT cont_color, PLINT cont_width,
2823  PLINT rectangular )
2824  {
2825  f2c( a, aa, nx, ny );
2826  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2827  clevel, nlevel, fill_width, cont_color, cont_width,
2828  plfill, rectangular, NULL, NULL );
2829  }
2830 
2831  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
2832  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2833  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2834  PLINT cont_color, PLINT cont_width,
2835  PLINT rectangular, PLFLT *tr )
2836  {
2837  f2c( a, aa, nx, ny );
2838  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2839  clevel, nlevel, fill_width, cont_color, cont_width,
2840  plfill, rectangular, xform, tr );
2841  }
2842 
2843  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
2844  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2845  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2846  PLINT cont_color, PLINT cont_width,
2847  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2848  {
2849  PLcGrid grid1;
2850  grid1.nx = nx; grid1.ny = ny;
2851  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2852 
2853  f2c( a, aa, nx, ny );
2854  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2855  clevel, nlevel, fill_width, cont_color, cont_width,
2856  plfill, rectangular, pltr1, &grid1 );
2857  }
2858 
2859  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
2860  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2861  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2862  PLINT cont_color, PLINT cont_width,
2863  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2864  {
2865  PLcGrid2 grid2;
2866  f2c( xg, xgg, nx, ny );
2867  f2c( yg, ygg, nx, ny );
2868  grid2.nx = nx; grid2.ny = ny;
2869  grid2.xg = xgg; grid2.yg = ygg;
2870  f2c( a, aa, nx, ny );
2871  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2872  clevel, nlevel, fill_width, cont_color, cont_width,
2873  plfill, rectangular, pltr2, &grid2 );
2874  }
2875 
2876 
2877 // Plot an array of vector arrows - uses the same function pointer
2878 // convention as plcont
2879 
2880  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2881  {
2882  f2c( u, uu, nx, ny );
2883  f2c( v, vv, nx, ny );
2884  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
2885  }
2886 
2887 // plvect() for use with pltr1
2888  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2889  {
2890  PLcGrid grid1;
2891  grid1.nx = nx; grid1.ny = ny;
2892  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2893  f2c( u, uu, nx, ny );
2894  f2c( v, vv, nx, ny );
2895  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
2896  }
2897 
2898 // plvect() for use with pltr2
2899  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2900  {
2901  PLcGrid2 grid2;
2902  f2c( xg, xgg, nx, ny );
2903  f2c( yg, ygg, nx, ny );
2904  grid2.nx = nx; grid2.ny = ny;
2905  grid2.xg = xgg; grid2.yg = ygg;
2906  f2c( u, uu, nx, ny );
2907  f2c( v, vv, nx, ny );
2908  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
2909  }
2910 
2911 
2912 // Plot an image with distortion - uses the same function pointer
2913  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
2914  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2915  PLFLT zmin, PLFLT zmax,
2916  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2917  {
2918  f2c( a, aa, nx, ny );
2919  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2920  }
2921 
2922 // Plot an image with distortion - uses the same function pointer
2923 // convention as plcont
2924  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
2925  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2926  PLFLT zmin, PLFLT zmax,
2927  PLFLT valuemin, PLFLT valuemax )
2928  {
2929  f2c( a, aa, nx, ny );
2930  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2931  }
2932 
2933  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
2934  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2935  PLFLT zmin, PLFLT zmax,
2936  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2937  {
2938  f2c( a, aa, nx, ny );
2939  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
2940  }
2941 
2942 // plimagefr() for use with pltr1
2943  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
2944  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2945  PLFLT zmin, PLFLT zmax,
2946  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2947  {
2948  PLcGrid grid1;
2949  grid1.nx = nx + 1; grid1.ny = ny + 1;
2950  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2951  f2c( a, aa, nx, ny );
2952  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
2953  }
2954 
2955 // plimagefr() for use with pltr2
2956  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
2957  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2958  PLFLT zmin, PLFLT zmax,
2959  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2960  {
2961  PLcGrid2 grid2;
2962  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
2963  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2964  grid2.nx = nx + 1; grid2.ny = ny + 1;
2965  grid2.xg = xgg; grid2.yg = ygg;
2966  f2c( a, aa, nx, ny );
2967  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
2968  }
2969 
2970 
2971 
2972  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
2973  PLINT opt, PLINT position, PLFLT x, PLFLT y,
2974  PLFLT x_length, PLFLT y_length,
2975  PLINT bg_color, PLINT bb_color, PLINT bb_style,
2976  PLFLT low_cap_color, PLFLT high_cap_color,
2977  PLINT cont_color, PLFLT cont_width,
2978  PLINT n_labels, const PLINT *label_opts, const char **label,
2979  PLINT n_axes, const char ** axis_opts,
2980  const PLFLT *ticks, const PLINT *sub_ticks,
2981  const PLINT *n_values, const PLFLT *a )
2982  {
2983  PLINT nx, ny, i;
2984  nx = n_axes;
2985  ny = -1;
2986  for ( i = 0; i < nx; i++ )
2987  if ( n_values[i] > ny )
2988  ny = n_values[i];
2989  f2c( a, aa, nx, ny );
2990  c_plcolorbar( p_colorbar_width, p_colorbar_height,
2991  opt, position, x, y,
2992  x_length, y_length,
2993  bg_color, bb_color, bb_style,
2994  low_cap_color, high_cap_color,
2995  cont_color, cont_width,
2996  n_labels, label_opts, label,
2997  n_axes, axis_opts,
2998  ticks, sub_ticks,
2999  n_values, aa );
3000  }
3001 
3002 
3003 
3004  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3005  {
3006  if (!ov.is_scalar_type())
3007  return SWIG_TypeError;
3008  if (ov.is_complex_scalar())
3009  return SWIG_TypeError;
3010  if (ov.is_double_type()||ov.is_single_type()) {
3011  double v=ov.double_value();
3012  if (v<0)
3013  return SWIG_OverflowError;
3014  if (v!=floor(v))
3015  return SWIG_TypeError;
3016  }
3017  if (ov.is_int8_type()||ov.is_int16_type()||
3018  ov.is_int32_type()) {
3019  long v=ov.long_value();
3020  if (v<0)
3021  return SWIG_OverflowError;
3022  }
3023  if (ov.is_int64_type()) {
3024  long long v=ov.int64_scalar_value().value();
3025  if (v<0)
3026  return SWIG_OverflowError;
3027  }
3028  if (val)
3029  *val = ov.ulong_value();
3030  return SWIG_OK;
3031  }
3032 
3033 
3034 SWIGINTERN int
3035 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3036 {
3037  unsigned long v;
3038  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3039  if (SWIG_IsOK(res)) {
3040  if ((v > UINT_MAX)) {
3041  return SWIG_OverflowError;
3042  } else {
3043  if (val) *val = (unsigned int)(v);
3044  }
3045  }
3046  return res;
3047 }
3048 
3049 
3051  {
3052  return octave_value(value);
3053  }
3054 
3055 
3056 SWIGINTERNINLINE octave_value
3058 {
3059  return SWIG_From_unsigned_SS_long (value);
3060 }
3061 
3062 
3063 SWIGINTERN int
3064 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3065 {
3066  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3067  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3068  if (SWIG_IsOK(res)) {
3069  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3070  if (csize <= size) {
3071  if (val) {
3072  if (csize) memcpy(val, cptr, csize*sizeof(char));
3073  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3074  }
3075  if (alloc == SWIG_NEWOBJ) {
3076  delete[] cptr;
3077  res = SWIG_DelNewMask(res);
3078  }
3079  return res;
3080  }
3081  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3082  }
3083  return SWIG_TypeError;
3084 }
3085 
3086 
3089 {
3090  static int init = 0;
3091  static swig_type_info* info = 0;
3092  if (!init) {
3093  info = SWIG_TypeQuery("_p_char");
3094  init = 1;
3095  }
3096  return info;
3097 }
3098 
3099 
3100 SWIGINTERNINLINE octave_value
3101 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3102 {
3103  return std::string(carray,carray+size);
3104 }
3105 
3106 
3107 SWIGINTERN int
3108 SWIG_AsVal_char (octave_value obj, char *val)
3109 {
3110  int res = SWIG_AsCharArray(obj, val, 1);
3111  if (!SWIG_IsOK(res)) {
3112  long v;
3113  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3114  if (SWIG_IsOK(res)) {
3115  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3116  if (val) *val = (char)(v);
3117  } else {
3118  res = SWIG_OverflowError;
3119  }
3120  }
3121  }
3122  return res;
3123 }
3124 
3125 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3126 Specify viewport in absolute coordinates\n\
3127 \n\
3128 DESCRIPTION:\n\
3129 \n\
3130  Alternate routine to plvpor for setting up the viewport. This routine\n\
3131  should be used only if the viewport is required to have a definite\n\
3132  size in millimeters. The routine plgspa is useful for finding out the\n\
3133  size of the current subpage.\n\
3134 \n\
3135  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3136 \n\
3137  This function is used in example 10.\n\
3138 \n\
3139 \n\
3140 \n\
3141 SYNOPSIS:\n\
3142 \n\
3143 plsvpa(xmin, xmax, ymin, ymax)\n\
3144 \n\
3145 ARGUMENTS:\n\
3146 \n\
3147  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3148  viewport from the left-hand edge of the subpage in millimeters.\n\
3149 \n\
3150  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3151  viewport from the left-hand edge of the subpage in millimeters.\n\
3152 \n\
3153  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3154  viewport from the bottom edge of the subpage in millimeters.\n\
3155 \n\
3156  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3157  from the bottom edge of the subpage in millimeters.\n\
3158 ";
3159 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3160 Write text relative to viewport boundaries in 3D plots\n\
3161 \n\
3162 DESCRIPTION:\n\
3163 \n\
3164  Writes text at a specified position relative to the viewport\n\
3165  boundaries. Text may be written inside or outside the viewport, but\n\
3166  is clipped at the subpage boundaries. The reference point of a string\n\
3167  lies along a line passing through the string at half the height of a\n\
3168  capital letter. The position of the reference point along this line\n\
3169  is determined by just, and the position of the reference point\n\
3170  relative to the viewport is set by disp and pos.\n\
3171 \n\
3172  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3173 \n\
3174  This function is used in example 28.\n\
3175 \n\
3176 \n\
3177 \n\
3178 SYNOPSIS:\n\
3179 \n\
3180 plmtex3(side, disp, pos, just, text)\n\
3181 \n\
3182 ARGUMENTS:\n\
3183 \n\
3184  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3185  the side of the viewport along which the text is to be written.\n\
3186  The string should contain one or more of the following characters:\n\
3187  [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3188  only label the X axis, not both the X and Y axes. x: Label the X\n\
3189  axis.\n\
3190  y: Label the Y axis.\n\
3191  z: Label the Z axis.\n\
3192  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3193  For X it is the axis that starts at y-min. For Y it is the\n\
3194  axis that starts at x-min.\n\
3195  s: Label the secondary axis.\n\
3196  v: Draw the text perpendicular to the axis.\n\
3197 \n\
3198 \n\
3199  disp (PLFLT, input) : Position of the reference point of string,\n\
3200  measured outwards from the specified viewport edge in units of the\n\
3201  current character height. Use negative disp to write within the\n\
3202  viewport.\n\
3203 \n\
3204  pos (PLFLT, input) : Position of the reference point of string\n\
3205  along the specified edge, expressed as a fraction of the length of\n\
3206  the edge.\n\
3207 \n\
3208  just (PLFLT, input) : Specifies the position of the string relative\n\
3209  to its reference point. If just=0. , the reference point is at\n\
3210  the left and if just=1. , it is at the right of the string. Other\n\
3211  values of just give intermediate justifications.\n\
3212 \n\
3213  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3214  written out.\n\
3215 ";
3216 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3217 Set semitransparent cmap1 RGBA colors.\n\
3218 \n\
3219 DESCRIPTION:\n\
3220 \n\
3221  Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3222  RGBA vector values. This function also sets the number of cmap1\n\
3223  colors. N.B. Continuous cmap1 colors are indexed with a\n\
3224  floating-point index in the range from 0.0-1.0 which is linearly\n\
3225  transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3226  vectors in the range from 0 to\n\
3227  ncol1-1. So in order for this continuous color model to work\n\
3228  properly, it is the responsibility of the user of plscmap1 to insure\n\
3229  that these RGBA vectors are continuous functions of their integer\n\
3230  indices.\n\
3231 \n\
3232  Redacted form: plscmap1a(r, g, b, alpha)\n\
3233 \n\
3234  This function is used in example 31.\n\
3235 \n\
3236 \n\
3237 \n\
3238 SYNOPSIS:\n\
3239 \n\
3240 plscmap1a(r, g, b, alpha, ncol1)\n\
3241 \n\
3242 ARGUMENTS:\n\
3243 \n\
3244  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3245  8-bit integers in the range from 0-255) the degree of red in the\n\
3246  color as a continuous function of the integer index of the vector.\n\
3247 \n\
3248  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3249  8-bit integers in the range from 0-255) the degree of green in the\n\
3250  color as a continuous function of the integer index of the vector.\n\
3251 \n\
3252  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3253  8-bit integers in the range from 0-255) the degree of blue in the\n\
3254  color as a continuous function of the integer index of the vector.\n\
3255 \n\
3256  alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3257  values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3258  completely transparent and 1.0 corresponds to completely opaque)\n\
3259  the alpha transparency of the color as a continuous function of\n\
3260  the integer index of the vector.\n\
3261 \n\
3262  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3263  vectors.\n\
3264 ";
3265 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3266 Select standard viewport\n\
3267 \n\
3268 DESCRIPTION:\n\
3269 \n\
3270  Selects the largest viewport within the subpage that leaves a standard\n\
3271  margin (left-hand margin of eight character heights, and a margin\n\
3272  around the other three sides of five character heights).\n\
3273 \n\
3274  Redacted form: plvsta()\n\
3275 \n\
3276  This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3277 \n\
3278 \n\
3279 \n\
3280 SYNOPSIS:\n\
3281 \n\
3282 plvsta()\n\
3283 ";
3284 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3285 Switch to graphics screen\n\
3286 \n\
3287 DESCRIPTION:\n\
3288 \n\
3289  Sets an interactive device to graphics mode, used in conjunction with\n\
3290  pltext to allow graphics and text to be interspersed. On a device\n\
3291  which supports separate text and graphics windows, this command causes\n\
3292  control to be switched to the graphics window. If already in graphics\n\
3293  mode, this command is ignored. It is also ignored on devices which\n\
3294  only support a single window or use a different method for shifting\n\
3295  focus. See also pltext.\n\
3296 \n\
3297  Redacted form: plgra()\n\
3298 \n\
3299  This function is used in example 1.\n\
3300 \n\
3301 \n\
3302 \n\
3303 SYNOPSIS:\n\
3304 \n\
3305 plgra()\n\
3306 ";
3307 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3308 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3309 \n\
3310 DESCRIPTION:\n\
3311 \n\
3312  Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3313  (see the PLplot documentation) index. Overwrites the previous color\n\
3314  value for the given index and, thus, does not result in any additional\n\
3315  allocation of space for colors.\n\
3316 \n\
3317  This function is used in example 30.\n\
3318 \n\
3319 \n\
3320 \n\
3321 SYNOPSIS:\n\
3322 \n\
3323 plscol0a(icol0, r, g, b, alpha)\n\
3324 \n\
3325 ARGUMENTS:\n\
3326 \n\
3327  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3328  number of colors (which is set by default, by plscmap0n, or even\n\
3329  by plscmap0).\n\
3330 \n\
3331  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3332  degree of red in the color.\n\
3333 \n\
3334  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3335  degree of green in the color.\n\
3336 \n\
3337  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3338  degree of blue in the color.\n\
3339 \n\
3340  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3341  (0.0-1.0).\n\
3342 ";
3343 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3344 Set y axis parameters\n\
3345 \n\
3346 DESCRIPTION:\n\
3347 \n\
3348  Identical to plsxax, except that arguments are flags for y axis. See\n\
3349  the description of plsxax for more detail.\n\
3350 \n\
3351  Redacted form: plsyax(digmax, digits)\n\
3352 \n\
3353  This function is used in examples 1, 14, and 31.\n\
3354 \n\
3355 \n\
3356 \n\
3357 SYNOPSIS:\n\
3358 \n\
3359 plsyax(digmax, digits)\n\
3360 \n\
3361 ARGUMENTS:\n\
3362 \n\
3363  digmax (PLINT, input) : Variable to set the maximum number of\n\
3364  digits for the y axis. If nonzero, the printed label will be\n\
3365  switched to a floating-point representation when the number of\n\
3366  digits exceeds digmax.\n\
3367 \n\
3368  digits (PLINT, input) : Field digits value. Currently, changing\n\
3369  its value here has no effect since it is set only by plbox or\n\
3370  plbox3. However, the user may obtain its value after a call to\n\
3371  either of these functions by calling plgyax.\n\
3372 ";
3373 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3374 Returns 8-bit RGB values for given color index from cmap0\n\
3375 \n\
3376 DESCRIPTION:\n\
3377 \n\
3378  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3379  PLplot documentation). Values are negative if an invalid color id is\n\
3380  given.\n\
3381 \n\
3382  Redacted form: plgcol0(icol0, r, g, b)\n\
3383 \n\
3384  This function is used in example 2.\n\
3385 \n\
3386 \n\
3387 \n\
3388 SYNOPSIS:\n\
3389 \n\
3390 plgcol0(icol0, r, g, b)\n\
3391 \n\
3392 ARGUMENTS:\n\
3393 \n\
3394  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3395 \n\
3396  r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3397  value.\n\
3398 \n\
3399  g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3400  value.\n\
3401 \n\
3402  b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3403  value.\n\
3404 ";
3405 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3406 Set seed for internal random number generator.\n\
3407 \n\
3408 DESCRIPTION:\n\
3409 \n\
3410  Set the seed for the internal random number generator. See plrandd for\n\
3411  further details.\n\
3412 \n\
3413  Redacted form: plseed(seed)\n\
3414 \n\
3415  This function is used in example 21.\n\
3416 \n\
3417 \n\
3418 \n\
3419 SYNOPSIS:\n\
3420 \n\
3421 plseed(seed)\n\
3422 \n\
3423 ARGUMENTS:\n\
3424 \n\
3425  seed (unsigned int, input) : Seed for random number generator.\n\
3426 ";
3427 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3428 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3429 \n\
3430 DESCRIPTION:\n\
3431 \n\
3432  When the implementation is completed this variant of plot3dc (see that\n\
3433  function\'s documentation for more details) should be suitable for the\n\
3434  case where the area of the x, y coordinate grid where z is defined can\n\
3435  be non-rectangular. The implementation is incomplete so the last 4\n\
3436  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3437  indexymax; are currently ignored and the functionality is otherwise\n\
3438  identical to that of plot3dc.\n\
3439 \n\
3440  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3441  indexymin, indexymax)\n\
3442 \t Perl/PDL: Not available?\n\
3443 \n\
3444 \n\
3445  This function is not used in any example.\n\
3446 \n\
3447 \n\
3448 \n\
3449 SYNOPSIS:\n\
3450 \n\
3451 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3452 \n\
3453 ARGUMENTS:\n\
3454 \n\
3455  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3456  which the function is evaluated.\n\
3457 \n\
3458  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3459  which the function is evaluated.\n\
3460 \n\
3461  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3462  plot. Should have dimensions of\n\
3463  nx by\n\
3464  ny.\n\
3465 \n\
3466  nx (PLINT, input) : Number of x values at which the function is\n\
3467  evaluated.\n\
3468 \n\
3469  ny (PLINT, input) : Number of y values at which the function is\n\
3470  evaluated.\n\
3471 \n\
3472  opt (PLINT, input) : Determines the way in which the surface is\n\
3473  represented. To specify more than one option just add the options,\n\
3474  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3475  showing z as a function of x for each value of y[j] .\n\
3476  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3477  for each value of x[i] .\n\
3478  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3479  at which function is defined.\n\
3480  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3481  the z value being plotted. The color is used from the current\n\
3482  cmap1.\n\
3483  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3484  using parameters\n\
3485  nlevel and\n\
3486  clevel.\n\
3487  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3488  the borders of the plotted function.\n\
3489 \n\
3490 \n\
3491  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3492  levels.\n\
3493 \n\
3494  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3495 \n\
3496  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3497  corresponds to the first x index where z is defined.\n\
3498 \n\
3499  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3500  which corresponds (by convention) to one more than the last x\n\
3501  index value where z is defined.\n\
3502 \n\
3503  indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3504  values which all must be ≥ 0. These values are the first y index\n\
3505  where z is defined for a particular x index in the range from\n\
3506  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3507  indexxmax.\n\
3508 \n\
3509  indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3510  values which all must be ≤ ny. These values correspond (by\n\
3511  convention) to one more than the last y index where z is defined\n\
3512  for a particular x index in the range from indexxmin to indexxmax\n\
3513  - 1. The dimension of indexymax is indexxmax.\n\
3514 ";
3515 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3516 Get output file name\n\
3517 \n\
3518 DESCRIPTION:\n\
3519 \n\
3520  Gets the current output file name, if applicable.\n\
3521 \n\
3522  Redacted form: plgfnam(fnam)\n\
3523 \n\
3524  This function is used in example 31.\n\
3525 \n\
3526 \n\
3527 \n\
3528 SYNOPSIS:\n\
3529 \n\
3530 plgfnam(fnam)\n\
3531 \n\
3532 ARGUMENTS:\n\
3533 \n\
3534  fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3535  (with preallocated length of 80 characters or more) containing the\n\
3536  file name.\n\
3537 ";
3538 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3539 Specify window\n\
3540 \n\
3541 DESCRIPTION:\n\
3542 \n\
3543  Specify the window, i.e., the world coordinates of the edges of the\n\
3544  viewport.\n\
3545 \n\
3546  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3547 \n\
3548  This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3549  29, and 31.\n\
3550 \n\
3551 \n\
3552 \n\
3553 SYNOPSIS:\n\
3554 \n\
3555 plwind(xmin, xmax, ymin, ymax)\n\
3556 \n\
3557 ARGUMENTS:\n\
3558 \n\
3559  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3560  of the viewport.\n\
3561 \n\
3562  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3563  of the viewport.\n\
3564 \n\
3565  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3566  the viewport.\n\
3567 \n\
3568  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3569  viewport.\n\
3570 ";
3571 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3572 Set cmap1 colors using a piece-wise linear relationship\n\
3573 \n\
3574 DESCRIPTION:\n\
3575 \n\
3576  Set cmap1 colors using a piece-wise linear relationship between the\n\
3577  cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3578  (see the PLplot documentation). May be called at any time.\n\
3579 \n\
3580  The idea here is to specify a number of control points that define the\n\
3581  mapping between input cmap1 intensity indices and HLS (or RGB).\n\
3582  Between these points, linear interpolation is used which gives a\n\
3583  smooth variation of color with intensity index. Any number of control\n\
3584  points may be specified, located at arbitrary positions, although\n\
3585  typically 2 - 4 are enough. Another way of stating this is that we are\n\
3586  traversing a given number of lines through HLS (or RGB) space as we\n\
3587  move through cmap1 intensity indices. The control points at the\n\
3588  minimum and maximum position (0 and 1) must always be specified. By\n\
3589  adding more control points you can get more variation. One good\n\
3590  technique for plotting functions that vary about some expected average\n\
3591  is to use an additional 2 control points in the center (position ~=\n\
3592  0.5) that are the same lightness as the background (typically white\n\
3593  for paper output, black for crt), and same hue as the boundary control\n\
3594  points. This allows the highs and lows to be very easily\n\
3595  distinguished.\n\
3596 \n\
3597  Each control point must specify the cmap1 intensity index and the\n\
3598  associated three coordinates in HLS or RGB space. The first point\n\
3599  must correspond to position = 0, and the last to position = 1.\n\
3600 \n\
3601  The default behaviour is for the hue to be linearly interpolated\n\
3602  between the control points. Since the hue lies in the range [0, 360]\n\
3603  this corresponds to interpolation around the \"front\" of the color\n\
3604  wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3605  alternative interpolation is used between control points i and i+1. If\n\
3606  hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n\
3607  - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n\
3608  this as interpolation around the \"back\" or \"reverse\" of the color\n\
3609  wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3610  alt_hue_path[] = false for every control point.\n\
3611 \n\
3612  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3613  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3614  240]truegreen-yellow-red-magenta-blue[240\n\
3615  120]trueblue-magenta-red-yellow-green\n\
3616 \n\
3617  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3618  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3619  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3620 \n\
3621  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3622  alt_hue_path)\n\
3623 \n\
3624  This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3625 \n\
3626 \n\
3627 \n\
3628 SYNOPSIS:\n\
3629 \n\
3630 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3631 \n\
3632 ARGUMENTS:\n\
3633 \n\
3634  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3635 \n\
3636  npts (PLINT, input) : number of control points\n\
3637 \n\
3638  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3639  intensity index (0.0-1.0) in ascending order for each control\n\
3640  point.\n\
3641 \n\
3642  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3643  coordinate (H or R) for each control point.\n\
3644 \n\
3645  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3646  coordinate (L or G) for each control point.\n\
3647 \n\
3648  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3649  coordinate (S or B) for each control point.\n\
3650 \n\
3651  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3652  npts - 1 elements) containing the alternative interpolation method\n\
3653  Boolean value for each control point interval. (alt_hue_path[i]\n\
3654  refers to the interpolation interval between the i and i + 1\n\
3655  control points).\n\
3656 ";
3657 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3658 Set the pause (on end-of-page) status\n\
3659 \n\
3660 DESCRIPTION:\n\
3661 \n\
3662  Set the pause (on end-of-page) status.\n\
3663 \n\
3664  Redacted form: plspause(pause)\n\
3665 \n\
3666  This function is in examples 14,20.\n\
3667 \n\
3668 \n\
3669 \n\
3670 SYNOPSIS:\n\
3671 \n\
3672 plspause(pause)\n\
3673 \n\
3674 ARGUMENTS:\n\
3675 \n\
3676  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3677  end-of-page for those drivers which support this. Otherwise there\n\
3678  is no pause.\n\
3679 ";
3680 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
3681 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
3682 \n\
3683 DESCRIPTION:\n\
3684 \n\
3685  Routine for creating a discrete plot legend with a plotted filled box,\n\
3686  line, and/or line of symbols for each annotated legend entry. (See\n\
3687  plcolorbar for similar functionality for creating continuous color\n\
3688  bars.) The arguments of pllegend provide control over the location\n\
3689  and size of the legend as well as the location and characteristics of\n\
3690  the elements (most of which are optional) within that legend. The\n\
3691  resulting legend is clipped at the boundaries of the current subpage.\n\
3692  (N.B. the adopted coordinate system used for some of the parameters is\n\
3693  defined in the documentation of the position parameter.)\n\
3694 \n\
3695  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3696  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3697  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3698  test_justification, text_colors, text, box_colors, box_patterns,\n\
3699  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3700  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3701 \n\
3702  This function is used in examples 4, 26, and 33.\n\
3703 \n\
3704 \n\
3705 \n\
3706 SYNOPSIS:\n\
3707 \n\
3708 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\
3709 \n\
3710 ARGUMENTS:\n\
3711 \n\
3712  p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
3713  legend width in adopted coordinates. This quantity is calculated\n\
3714  from plot_width, text_offset, ncolumn (possibly modified inside\n\
3715  the routine depending on nlegend and nrow), and the length\n\
3716  (calculated internally) of the longest text string.\n\
3717 \n\
3718  p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
3719  legend height in adopted coordinates. This quantity is calculated\n\
3720  from text_scale, text_spacing, and nrow (possibly modified inside\n\
3721  the routine depending on nlegend and nrow).\n\
3722 \n\
3723  opt (PLINT, input) : opt contains bits controlling the overall\n\
3724  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3725  on the left of the legend and the plotted area on the right.\n\
3726  Otherwise, put the text area on the right of the legend and the\n\
3727  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3728  plot a (semitransparent) background for the legend. If the\n\
3729  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3730  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3731  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3732  plot the resulting array of legend entries in row-major order.\n\
3733  Otherwise, plot the legend entries in column-major order.\n\
3734 \n\
3735  position (PLINT, input) : position contains bits which control the\n\
3736  overall position of the legend and the definition of the adopted\n\
3737  coordinates used for positions just like what is done for the\n\
3738  position argument for plcolorbar. However, note that the defaults\n\
3739  for the position bits (see below) are different than the\n\
3740  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3741  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3742  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3743  the 16 possible standard positions (the 4 corners and centers of\n\
3744  the 4 sides for both the inside and outside cases) of the legend\n\
3745  relative to the adopted coordinate system. The corner positions\n\
3746  are specified by the appropriate combination of two of the\n\
3747  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3748  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3749  value of one of those bits. The adopted coordinates are\n\
3750  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3751  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3752  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3753  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3754  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3755  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3756  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3757  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
3758 \n\
3759  x (PLFLT, input) : X offset of the legend position in adopted\n\
3760  coordinates from the specified standard position of the legend.\n\
3761  For positive x, the direction of motion away from the standard\n\
3762  position is inward/outward from the standard corner positions or\n\
3763  standard left or right positions if the\n\
3764  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
3765  For the standard top or bottom positions, the direction of motion\n\
3766  is toward positive X.\n\
3767 \n\
3768  y (PLFLT, input) : Y offset of the legend position in adopted\n\
3769  coordinates from the specified standard position of the legend.\n\
3770  For positive y, the direction of motion away from the standard\n\
3771  position is inward/outward from the standard corner positions or\n\
3772  standard top or bottom positions if the\n\
3773  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
3774  the standard left or right positions, the direction of motion is\n\
3775  toward positive Y.\n\
3776 \n\
3777  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3778  of the plot area (where the colored boxes, lines, and/or lines of\n\
3779  symbols are drawn) of the legend.\n\
3780 \n\
3781  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3782  legend (PL_LEGEND_BACKGROUND).\n\
3783 \n\
3784  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3785  for the legend (PL_LEGEND_BOUNDING_BOX).\n\
3786 \n\
3787  bb_style (PLINT, input) : The pllsty style number for the\n\
3788  bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
3789 \n\
3790  nrow (PLINT, input) : The cmap0 index of the background color for\n\
3791  the legend (PL_LEGEND_BACKGROUND).\n\
3792 \n\
3793  ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3794  for the legend (PL_LEGEND_BACKGROUND).\n\
3795 \n\
3796  nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3797  vertical height of the legend in adopted coordinates is calculated\n\
3798  internally from nlegend, text_scale (see below), and text_spacing\n\
3799  (see below).\n\
3800 \n\
3801  opt_array (PLINT_VECTOR, input) : A vector of\n\
3802  nlegend values of options to control each individual plotted area\n\
3803  corresponding to a legend entry. If the\n\
3804  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3805  area. If the\n\
3806  PL_LEGEND_COLOR_BOX,\n\
3807  PL_LEGEND_LINE, and/or\n\
3808  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3809  entry is plotted with a colored box; a line; and/or a line of\n\
3810  symbols.\n\
3811 \n\
3812  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3813  area in units of character width. N.B. The total horizontal\n\
3814  width of the legend in adopted coordinates is calculated\n\
3815  internally from\n\
3816  plot_width (see above),\n\
3817  text_offset, and length (calculated internally) of the longest text\n\
3818  string.\n\
3819 \n\
3820  text_scale (PLFLT, input) : Character height scale for text\n\
3821  annotations. N.B. The total vertical height of the legend in\n\
3822  adopted coordinates is calculated internally from\n\
3823  nlegend (see above),\n\
3824  text_scale, and\n\
3825  text_spacing (see below).\n\
3826 \n\
3827  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3828  character height from one legend entry to the next. N.B. The\n\
3829  total vertical height of the legend in adopted coordinates is\n\
3830  calculated internally from\n\
3831  nlegend (see above),\n\
3832  text_scale (see above), and\n\
3833  text_spacing.\n\
3834 \n\
3835  text_justification (PLFLT, input) : Justification parameter used\n\
3836  for text justification. The most common values of\n\
3837  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3838  is left justified, centred, or right justified within the text\n\
3839  area, but other values are allowed as well.\n\
3840 \n\
3841  text_colors (PLINT_VECTOR, input) : A vector containing\n\
3842  nlegend cmap0 text colors.\n\
3843 \n\
3844  text (PLCHAR_MATRIX, input) : A vector of\n\
3845  nlegend UTF-8 character strings containing the legend annotations.\n\
3846 \n\
3847  box_colors (PLINT_VECTOR, input) : A vector containing\n\
3848  nlegend cmap0 colors for the discrete colored boxes (\n\
3849  PL_LEGEND_COLOR_BOX).\n\
3850 \n\
3851  box_patterns (PLINT_VECTOR, input) : A vector containing\n\
3852  nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
3853  PL_LEGEND_COLOR_BOX).\n\
3854 \n\
3855  box_scales (PLFLT_VECTOR, input) : A vector containing\n\
3856  nlegend scales (units of fraction of character height) for the height\n\
3857  of the discrete colored boxes (\n\
3858  PL_LEGEND_COLOR_BOX).\n\
3859 \n\
3860  box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
3861  nlegend line widths for the patterns specified by box_patterns (\n\
3862  PL_LEGEND_COLOR_BOX).\n\
3863 \n\
3864  line_colors (PLINT_VECTOR, input) : A vector containing\n\
3865  nlegend cmap0 line colors (\n\
3866  PL_LEGEND_LINE).\n\
3867 \n\
3868  line_styles (PLINT_VECTOR, input) : A vector containing\n\
3869  nlegend line styles (plsty indices) (\n\
3870  PL_LEGEND_LINE).\n\
3871 \n\
3872  line_widths (PLFLT_VECTOR, input) : A vector containing\n\
3873  nlegend line widths (\n\
3874  PL_LEGEND_LINE).\n\
3875 \n\
3876  symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
3877  nlegend cmap0 symbol colors (\n\
3878  PL_LEGEND_SYMBOL).\n\
3879 \n\
3880  symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
3881  nlegend scale values for the symbol height (\n\
3882  PL_LEGEND_SYMBOL).\n\
3883 \n\
3884  symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
3885  nlegend numbers of symbols to be drawn across the width of the plotted\n\
3886  area (\n\
3887  PL_LEGEND_SYMBOL).\n\
3888 \n\
3889  symbols (PLCHAR_MATRIX, input) : A vector of\n\
3890  nlegend UTF-8 character strings containing the legend symbols. (\n\
3891  PL_LEGEND_SYMBOL).\n\
3892 ";
3893 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
3894 Set number of colors in cmap1\n\
3895 \n\
3896 DESCRIPTION:\n\
3897 \n\
3898  Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
3899  values if this is the first allocation (see the PLplot documentation).\n\
3900 \n\
3901  Redacted form: plscmap1n(ncol1)\n\
3902 \n\
3903  This function is used in examples 8, 11, 20, and 21.\n\
3904 \n\
3905 \n\
3906 \n\
3907 SYNOPSIS:\n\
3908 \n\
3909 plscmap1n(ncol1)\n\
3910 \n\
3911 ARGUMENTS:\n\
3912 \n\
3913  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3914  the cmap1 palette. If this number is zero or less, then the value\n\
3915  from the previous call to plscmap1n is used and if there is no\n\
3916  previous call, then a default value is used.\n\
3917 ";
3918 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
3919 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
3920 \n\
3921 DESCRIPTION:\n\
3922 \n\
3923  Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
3924  (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
3925  Values are negative if an invalid color id is given.\n\
3926 \n\
3927  Redacted form: plgcola(r, g, b)\n\
3928 \n\
3929  This function is used in example 30.\n\
3930 \n\
3931 \n\
3932 \n\
3933 SYNOPSIS:\n\
3934 \n\
3935 plgcol0a(icol0, r, g, b, alpha)\n\
3936 \n\
3937 ARGUMENTS:\n\
3938 \n\
3939  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3940 \n\
3941  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
3942  in the range from 0 to 255.\n\
3943 \n\
3944  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
3945  in the range from 0 to 255.\n\
3946 \n\
3947  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
3948  in the range from 0 to 255.\n\
3949 \n\
3950  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
3951  transparency in the range from (0.0-1.0).\n\
3952 ";
3953 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
3954 Replays contents of plot buffer to current device/file\n\
3955 \n\
3956 DESCRIPTION:\n\
3957 \n\
3958  Replays contents of plot buffer to current device/file.\n\
3959 \n\
3960  Redacted form: plreplot()\n\
3961 \n\
3962  This function is used in example 1,20.\n\
3963 \n\
3964 \n\
3965 \n\
3966 SYNOPSIS:\n\
3967 \n\
3968 plreplot()\n\
3969 ";
3970 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
3971 Simple routine to write labels\n\
3972 \n\
3973 DESCRIPTION:\n\
3974 \n\
3975  Routine for writing simple labels. Use plmtex for more complex labels.\n\
3976 \n\
3977  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3978 \n\
3979  This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
3980 \n\
3981 \n\
3982 \n\
3983 SYNOPSIS:\n\
3984 \n\
3985 pllab(xlabel, ylabel, tlabel)\n\
3986 \n\
3987 ARGUMENTS:\n\
3988 \n\
3989  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3990  the label for the x axis.\n\
3991 \n\
3992  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3993  the label for the y axis.\n\
3994 \n\
3995  tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
3996  the title of the plot.\n\
3997 ";
3998 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
3999 Set parameters that define current device-space window\n\
4000 \n\
4001 DESCRIPTION:\n\
4002 \n\
4003  Set relative margin width, aspect ratio, and relative justification\n\
4004  that define current device-space window. If you want to just use the\n\
4005  previous value for any of these, just pass in the magic value\n\
4006  PL_NOTSET. It is unlikely that one should ever need to change the\n\
4007  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4008  called the default values of mar, jx, and jy are all 0. aspect is set\n\
4009  to a device-specific value.\n\
4010 \n\
4011  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4012 \n\
4013  This function is used in example 31.\n\
4014 \n\
4015 \n\
4016 \n\
4017 SYNOPSIS:\n\
4018 \n\
4019 plsdidev(mar, aspect, jx, jy)\n\
4020 \n\
4021 ARGUMENTS:\n\
4022 \n\
4023  mar (PLFLT, input) : Relative margin width.\n\
4024 \n\
4025  aspect (PLFLT, input) : Aspect ratio.\n\
4026 \n\
4027  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4028  the range -0.5 to 0.5.\n\
4029 \n\
4030  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4031  the range -0.5 to 0.5.\n\
4032 ";
4033 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4034 Begin a new page\n\
4035 \n\
4036 DESCRIPTION:\n\
4037 \n\
4038  Begins a new page.\tFor a file driver, the output file is opened if\n\
4039  necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
4040  page break is desired at a particular point when plotting to subpages.\n\
4041  Another use for pleop and plbop is when plotting pages to different\n\
4042  files, since you can manually set the file name by calling plsfnam\n\
4043  after the call to pleop. (In fact some drivers may only support a\n\
4044  single page per file, making this a necessity.) One way to handle\n\
4045  this case automatically is to page advance via pladv, but enable\n\
4046  familying (see plsfam) with a small limit on the file size so that a\n\
4047  new family member file will be created on each page break.\n\
4048 \n\
4049  Redacted form: plbop()\n\
4050 \n\
4051  This function is used in examples 2 and 20.\n\
4052 \n\
4053 \n\
4054 \n\
4055 SYNOPSIS:\n\
4056 \n\
4057 plbop()\n\
4058 ";
4059 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4060 Set cmap0 colors by 8-bit RGB values\n\
4061 \n\
4062 DESCRIPTION:\n\
4063 \n\
4064  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4065  documentation). This sets the entire color map -- only as many colors\n\
4066  as specified will be allocated.\n\
4067 \n\
4068  Redacted form: plscmap0(r, g, b)\n\
4069 \n\
4070  This function is used in examples 2 and 24.\n\
4071 \n\
4072 \n\
4073 \n\
4074 SYNOPSIS:\n\
4075 \n\
4076 plscmap0(r, g, b, ncol0)\n\
4077 \n\
4078 ARGUMENTS:\n\
4079 \n\
4080  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4081  integers (0-255) representing the degree of red in the color.\n\
4082 \n\
4083  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4084  integers (0-255) representing the degree of green in the color.\n\
4085 \n\
4086  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4087  integers (0-255) representing the degree of blue in the color.\n\
4088 \n\
4089  ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4090 ";
4091 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4092 Set the number of subpages in x and y\n\
4093 \n\
4094 DESCRIPTION:\n\
4095 \n\
4096  Set the number of subpages in x and y.\n\
4097 \n\
4098  Redacted form: plssub(nx, ny)\n\
4099 \n\
4100  This function is examples 1,2,14,21,25,27.\n\
4101 \n\
4102 \n\
4103 \n\
4104 SYNOPSIS:\n\
4105 \n\
4106 plssub(nx, ny)\n\
4107 \n\
4108 ARGUMENTS:\n\
4109 \n\
4110  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4111  of window columns).\n\
4112 \n\
4113  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4114  of window rows).\n\
4115 ";
4116 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4117 Set a global coordinate transform function\n\
4118 \n\
4119 DESCRIPTION:\n\
4120 \n\
4121  This function can be used to define a coordinate transformation which\n\
4122  affects all elements drawn within the current plot window.\tThe\n\
4123  coordinate_transform callback function is similar to that provided for\n\
4124  the plmap and plmeridians functions. The coordinate_transform_data\n\
4125  parameter may be used to pass extra data to coordinate_transform.\n\
4126 \n\
4127  Redacted form: General: plstransform(coordinate_transform,\n\
4128  coordinate_transform_data)\n\
4129 \n\
4130 \n\
4131  This function is used in examples 19 and 22.\n\
4132 \n\
4133 \n\
4134 \n\
4135 SYNOPSIS:\n\
4136 \n\
4137 plstransform(coordinate_transform, coordinate_transform_data)\n\
4138 \n\
4139 ARGUMENTS:\n\
4140 \n\
4141  coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4142  function that defines the transformation from the input (x, y)\n\
4143  world coordinates to new PLplot world coordinates. If\n\
4144  coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4145  case), then no transform is applied.\n\
4146 \n\
4147  coordinate_transform_data (PL_GENERIC_POINTER, input) : Optional\n\
4148  extra data for\n\
4149  coordinate_transform.\n\
4150 ";
4151 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4152 Set opaque RGB cmap1 colors values\n\
4153 \n\
4154 DESCRIPTION:\n\
4155 \n\
4156  Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4157  vector values. This function also sets the number of cmap1 colors.\n\
4158  N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4159  in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4160  plcol1) to an integer index of these RGB vectors in the range from 0\n\
4161  to\n\
4162  ncol1-1. So in order for this continuous color model to work\n\
4163  properly, it is the responsibility of the user of plscmap1 to insure\n\
4164  that these RGB vectors are continuous functions of their integer\n\
4165  indices.\n\
4166 \n\
4167  Redacted form: plscmap1(r, g, b)\n\
4168 \n\
4169  This function is used in example 31.\n\
4170 \n\
4171 \n\
4172 \n\
4173 SYNOPSIS:\n\
4174 \n\
4175 plscmap1(r, g, b, ncol1)\n\
4176 \n\
4177 ARGUMENTS:\n\
4178 \n\
4179  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4180  8-bit integers in the range from 0-255) the degree of red in the\n\
4181  color as a continuous function of the integer index of the vector.\n\
4182 \n\
4183  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4184  8-bit integers in the range from 0-255) the degree of green in the\n\
4185  color as a continuous function of the integer index of the vector.\n\
4186 \n\
4187  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4188  8-bit integers in the range from 0-255) the degree of blue in the\n\
4189  color as a continuous function of the integer index of the vector.\n\
4190 \n\
4191  ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4192 ";
4193 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4194 Configure the transformation between continuous and broken-down time for the current stream\n\
4195 \n\
4196 DESCRIPTION:\n\
4197 \n\
4198  Configure the transformation between continuous and broken-down time\n\
4199  for the current stream. This transformation is used by both plbtime\n\
4200  and plctime.\n\
4201 \n\
4202  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4203  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4204 \t Perl/PDL: Not available?\n\
4205 \n\
4206 \n\
4207  This function is used in example 29.\n\
4208 \n\
4209 \n\
4210 \n\
4211 SYNOPSIS:\n\
4212 \n\
4213 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4214 \n\
4215 ARGUMENTS:\n\
4216 \n\
4217  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4218  As a special case, if\n\
4219  scale is 0., then all other arguments are ignored, and the result (the\n\
4220  default used by PLplot) is the equivalent of a call to\n\
4221  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4222  That is, for this special case broken-down time is calculated with\n\
4223  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4224  and the continuous time is defined as the number of seconds since\n\
4225  the Unix epoch of 1970-01-01T00:00:00Z.\n\
4226 \n\
4227  offset1 (PLFLT, input) : If\n\
4228  ifbtime_offset is true, the parameters\n\
4229  offset1 and\n\
4230  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4231  (with units in days) specify the epoch of the continuous time\n\
4232  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4233  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4234  are used to specify the origin to allow users (by specifying\n\
4235  offset1 as an integer that can be exactly represented by a\n\
4236  floating-point variable and specifying\n\
4237  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4238  the numerical errors of the continuous time representation.\n\
4239 \n\
4240  offset2 (PLFLT, input) : See documentation of\n\
4241  offset1.\n\
4242 \n\
4243  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4244  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4245  calendar is used for broken-down time rather than the proleptic\n\
4246  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4247  have been historically used to define UTC are inserted into the\n\
4248  broken-down time. Other possibilities for additional control bits\n\
4249  for ccontrol exist such as making the historical time corrections\n\
4250  in the broken-down time corresponding to ET (ephemeris time) or\n\
4251  making the (slightly non-constant) corrections from international\n\
4252  atomic time (TAI) to what astronomers define as terrestrial time\n\
4253  (TT). But those additional possibilities have not been\n\
4254  implemented yet in the qsastime library (one of the PLplot utility\n\
4255  libraries).\n\
4256 \n\
4257  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4258  epoch of the continuous time scale is specified by the user. If\n\
4259  ifbtime_offset is false, then\n\
4260  offset1 and\n\
4261  offset2 are used to specify the epoch, and the following broken-down\n\
4262  time parameters are completely ignored. If\n\
4263  ifbtime_offset is true, then\n\
4264  offset1 and\n\
4265  offset2 are completely ignored, and the following broken-down time\n\
4266  parameters are used to specify the epoch.\n\
4267 \n\
4268  year (PLINT, input) : Year of epoch.\n\
4269 \n\
4270  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4271  11 (December).\n\
4272 \n\
4273  day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4274 \n\
4275  hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4276 \n\
4277  min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4278 \n\
4279  sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4280 ";
4281 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4282 Set length of minor ticks\n\
4283 \n\
4284 DESCRIPTION:\n\
4285 \n\
4286  This sets up the length of the minor ticks and the length of the\n\
4287  terminals on error bars. The actual length is the product of the\n\
4288  default length and a scaling factor as for character height.\n\
4289 \n\
4290  Redacted form: plsmin(def, scale)\n\
4291 \n\
4292  This function is used in example 29.\n\
4293 \n\
4294 \n\
4295 \n\
4296 SYNOPSIS:\n\
4297 \n\
4298 plsmin(def, scale)\n\
4299 \n\
4300 ARGUMENTS:\n\
4301 \n\
4302  def (PLFLT, input) : The default length of a minor tick in\n\
4303  millimeters, should be set to zero if the default length is to\n\
4304  remain unchanged.\n\
4305 \n\
4306  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4307  actual tick length.\n\
4308 ";
4309 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4310 Set character size\n\
4311 \n\
4312 DESCRIPTION:\n\
4313 \n\
4314  This sets up the size of all subsequent characters drawn. The actual\n\
4315  height of a character is the product of the default character size and\n\
4316  a scaling factor.\n\
4317 \n\
4318  Redacted form: plschr(def, scale)\n\
4319 \n\
4320  This function is used in examples 2, 13, 23, and 24.\n\
4321 \n\
4322 \n\
4323 \n\
4324 SYNOPSIS:\n\
4325 \n\
4326 plschr(def, scale)\n\
4327 \n\
4328 ARGUMENTS:\n\
4329 \n\
4330  def (PLFLT, input) : The default height of a character in\n\
4331  millimeters, should be set to zero if the default height is to\n\
4332  remain unchanged. For rasterized drivers the dx and dy values\n\
4333  specified in plspage are used to convert from mm to pixels (note\n\
4334  the different unit systems used). This dpi aware scaling is not\n\
4335  implemented for all drivers yet.\n\
4336 \n\
4337  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4338  actual character height.\n\
4339 ";
4340 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4341 Initialize PLplot\n\
4342 \n\
4343 DESCRIPTION:\n\
4344 \n\
4345  Initializing the plotting package.\tThe program prompts for the device\n\
4346  keyword or number of the desired output device. Hitting a RETURN in\n\
4347  response to the prompt is the same as selecting the first device.\n\
4348  plinit will issue no prompt if either the device was specified\n\
4349  previously (via command line flag, the plsetopt function, or the\n\
4350  plsdev function), or if only one device is enabled when PLplot is\n\
4351  installed.\tIf subpages have been specified, the output device is\n\
4352  divided into nx by ny subpages, each of which may be used\n\
4353  independently. If plinit is called again during a program, the\n\
4354  previously opened file will be closed. The subroutine pladv is used\n\
4355  to advance from one subpage to the next.\n\
4356 \n\
4357  Redacted form: plinit()\n\
4358 \n\
4359  This function is used in all of the examples.\n\
4360 \n\
4361 \n\
4362 \n\
4363 SYNOPSIS:\n\
4364 \n\
4365 plinit()\n\
4366 ";
4367 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4368 Draw a box with axes, etc\n\
4369 \n\
4370 DESCRIPTION:\n\
4371 \n\
4372  Draws a box around the currently defined viewport, and labels it with\n\
4373  world coordinate values appropriate to the window.\tThus plbox should\n\
4374  only be called after defining both viewport and window. The ascii\n\
4375  character strings xopt and yopt specify how the box should be drawn as\n\
4376  described below. If ticks and/or subticks are to be drawn for a\n\
4377  particular axis, the tick intervals and number of subintervals may be\n\
4378  specified explicitly, or they may be defaulted by setting the\n\
4379  appropriate arguments to zero.\n\
4380 \n\
4381  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4382 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4383 \n\
4384 \n\
4385  This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4386  and 29.\n\
4387 \n\
4388 \n\
4389 \n\
4390 SYNOPSIS:\n\
4391 \n\
4392 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4393 \n\
4394 ARGUMENTS:\n\
4395 \n\
4396  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4397  options for the x axis. The string can include any combination of\n\
4398  the following letters (upper or lower case) in any order: a: Draws\n\
4399  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4400  (x=0).\n\
4401  b: Draws bottom (X) or left (Y) edge of frame.\n\
4402  c: Draws top (X) or right (Y) edge of frame.\n\
4403  d: Plot labels as date / time. Values are assumed to be\n\
4404  seconds since the epoch (as used by gmtime).\n\
4405  f: Always use fixed point numeric labels.\n\
4406  g: Draws a grid at the major tick interval.\n\
4407  h: Draws a grid at the minor tick interval.\n\
4408  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4409  inwards.\n\
4410  l: Labels axis logarithmically. This only affects the labels,\n\
4411  not the data, and so it is necessary to compute the logarithms\n\
4412  of data points before passing them to any of the drawing\n\
4413  routines.\n\
4414  m: Writes numeric labels at major tick intervals in the\n\
4415  unconventional location (above box for X, right of box for Y).\n\
4416  n: Writes numeric labels at major tick intervals in the\n\
4417  conventional location (below box for X, left of box for Y).\n\
4418  o: Use custom labelling function to generate axis label text.\n\
4419  The custom labelling function can be defined with the\n\
4420  plslabelfunc command.\n\
4421  s: Enables subticks between major ticks, only valid if t is\n\
4422  also specified.\n\
4423  t: Draws major ticks.\n\
4424  u: Exactly like \"b\" except don\'t draw edge line.\n\
4425  w: Exactly like \"c\" except don\'t draw edge line.\n\
4426  x: Exactly like \"t\" (including the side effect of the\n\
4427  numerical labels for the major ticks) except exclude drawing\n\
4428  the major and minor tick marks.\n\
4429 \n\
4430 \n\
4431  xtick (PLFLT, input) : World coordinate interval between major\n\
4432  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4433  generates a suitable tick interval.\n\
4434 \n\
4435  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4436  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4437  generates a suitable minor tick interval.\n\
4438 \n\
4439  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4440  options for the y axis. The string can include any combination of\n\
4441  the letters defined above for xopt, and in addition may contain:\n\
4442  v: Write numeric labels for the y axis parallel to the base of the\n\
4443  graph, rather than parallel to the axis.\n\
4444 \n\
4445 \n\
4446  ytick (PLFLT, input) : World coordinate interval between major\n\
4447  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4448  generates a suitable tick interval.\n\
4449 \n\
4450  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4451  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4452  generates a suitable minor tick interval.\n\
4453 ";
4454 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4455 Get parameters that define current device-space window\n\
4456 \n\
4457 DESCRIPTION:\n\
4458 \n\
4459  Get relative margin width, aspect ratio, and relative justification\n\
4460  that define current device-space window. If plsdidev has not been\n\
4461  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4462  p_jy will all be 0.\n\
4463 \n\
4464  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4465 \n\
4466  This function is used in example 31.\n\
4467 \n\
4468 \n\
4469 \n\
4470 SYNOPSIS:\n\
4471 \n\
4472 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4473 \n\
4474 ARGUMENTS:\n\
4475 \n\
4476  p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4477  margin width.\n\
4478 \n\
4479  p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4480  ratio.\n\
4481 \n\
4482  p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4483  justification in x.\n\
4484 \n\
4485  p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4486  justification in y.\n\
4487 ";
4488 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4489 Plot a glyph at the specified points\n\
4490 \n\
4491 DESCRIPTION:\n\
4492 \n\
4493  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4494  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4495  is specified with a PLplot user string. Note that the user string is\n\
4496  not actually limited to one glyph so it is possible (but not normally\n\
4497  useful) to plot more than one glyph at the specified points with this\n\
4498  function. As with plmtex and plptex, the user string can contain FCI\n\
4499  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4500  else PLplot escapes for Hershey or unicode text to determine the\n\
4501  glyph.\n\
4502 \n\
4503  Redacted form: plstring(x, y, string)\n\
4504 \n\
4505  This function is used in examples 4, 21 and 26.\n\
4506 \n\
4507 \n\
4508 \n\
4509 SYNOPSIS:\n\
4510 \n\
4511 plstring(n, x, y, string)\n\
4512 \n\
4513 ARGUMENTS:\n\
4514 \n\
4515  n (PLINT, input) : Number of points in the x and y vectors.\n\
4516 \n\
4517  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4518  the points.\n\
4519 \n\
4520  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4521  the points.\n\
4522 \n\
4523  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4524  the glyph(s) to be plotted at each of the n points.\n\
4525 ";
4526 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4527 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4528 \n\
4529 DESCRIPTION:\n\
4530 \n\
4531  As per plmapline, however the items are plotted as strings or points\n\
4532  in the same way as plstring.\n\
4533 \n\
4534  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4535  maxy, plotentries)\n\
4536 \n\
4537  This function is not used in any examples.\n\
4538 \n\
4539 \n\
4540 \n\
4541 SYNOPSIS:\n\
4542 \n\
4543 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4544 \n\
4545 ARGUMENTS:\n\
4546 \n\
4547  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4548  transform the coordinates given in the shapefile into a plot\n\
4549  coordinate system. By using this transform, we can change from a\n\
4550  longitude, latitude coordinate to a polar stereographic project,\n\
4551  for example. Initially, x[0]..[n-1] are the longitudes and\n\
4552  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4553  mapform(), x[] and y[] should be replaced by the corresponding\n\
4554  plot coordinates. If no transform is desired, mapform can be\n\
4555  replaced by NULL.\n\
4556 \n\
4557  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4558  the file name of a set of Shapefile files without the file\n\
4559  extension.\n\
4560 \n\
4561  string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4562  drawn.\n\
4563 \n\
4564  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4565  be in the same units as used by the Shapefile. You could use a\n\
4566  very large negative number to plot everything, but you can improve\n\
4567  performance by limiting the area drawn. The units must match those\n\
4568  of the Shapefile projection, which may be for example longitude or\n\
4569  distance. The value of minx must be less than the value of maxx.\n\
4570 \n\
4571  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4572  use a very large number to plot everything, but you can improve\n\
4573  performance by limiting the area drawn.\n\
4574 \n\
4575  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4576  be in the same units as used by the Shapefile. You could use a\n\
4577  very large negative number to plot everything, but you can improve\n\
4578  performance by limiting the area drawn. The units must match those\n\
4579  of the Shapefile projection, which may be for example latitude or\n\
4580  distance. The value of miny must be less than the value of maxy.\n\
4581 \n\
4582  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4583  use a very large number to plot everything, but you can improve\n\
4584  performance by limiting the area drawn.\n\
4585 \n\
4586  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4587  zero-based indices of the Shapefile elements which will be drawn.\n\
4588  Setting\n\
4589  plotentries to NULL will plot all elements of the Shapefile.\n\
4590 \n\
4591  nplotentries (PLINT, input) : The number of items in\n\
4592  plotentries. Ignored if\n\
4593  plotentries is NULL.\n\
4594 ";
4595 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4596 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4597 \n\
4598 DESCRIPTION:\n\
4599 \n\
4600  Sets up plotter environment for simple graphs by calling pladv and\n\
4601  setting up viewport and window to sensible default values. plenv0\n\
4602  leaves a standard margin (left-hand margin of eight character heights,\n\
4603  and a margin around the other three sides of five character heights)\n\
4604  around most graphs for axis labels and a title. When these defaults\n\
4605  are not suitable, use the individual routines plvpas, plvpor, or\n\
4606  plvasp for setting up the viewport, plwind for defining the window,\n\
4607  and plbox for drawing the box.\n\
4608 \n\
4609  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4610 \n\
4611  This function is used in example 21.\n\
4612 \n\
4613 \n\
4614 \n\
4615 SYNOPSIS:\n\
4616 \n\
4617 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4618 \n\
4619 ARGUMENTS:\n\
4620 \n\
4621  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4622  world coordinates).\n\
4623 \n\
4624  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4625  world coordinates).\n\
4626 \n\
4627  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4628  coordinates).\n\
4629 \n\
4630  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4631  coordinates).\n\
4632 \n\
4633  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4634  scales will not be set, the user must set up the scale before\n\
4635  calling plenv0 using plsvpa, plvasp or other.\n\
4636  0: the x and y axes are scaled independently to use as much of\n\
4637  the screen as possible.\n\
4638  1: the scales of the x and y axes are made equal.\n\
4639  2: the axis of the x and y axes are made equal, and the plot\n\
4640  box will be square.\n\
4641 \n\
4642 \n\
4643  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4644  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4645  -1: draw box only.\n\
4646  0: draw box, ticks, and numeric tick labels.\n\
4647  1: also draw coordinate axes at x=0 and y=0.\n\
4648  2: also draw a grid at major tick positions in both\n\
4649  coordinates.\n\
4650  3: also draw a grid at minor tick positions in both\n\
4651  coordinates.\n\
4652  10: same as 0 except logarithmic x tick marks. (The x data\n\
4653  have to be converted to logarithms separately.)\n\
4654  11: same as 1 except logarithmic x tick marks. (The x data\n\
4655  have to be converted to logarithms separately.)\n\
4656  12: same as 2 except logarithmic x tick marks. (The x data\n\
4657  have to be converted to logarithms separately.)\n\
4658  13: same as 3 except logarithmic x tick marks. (The x data\n\
4659  have to be converted to logarithms separately.)\n\
4660  20: same as 0 except logarithmic y tick marks. (The y data\n\
4661  have to be converted to logarithms separately.)\n\
4662  21: same as 1 except logarithmic y tick marks. (The y data\n\
4663  have to be converted to logarithms separately.)\n\
4664  22: same as 2 except logarithmic y tick marks. (The y data\n\
4665  have to be converted to logarithms separately.)\n\
4666  23: same as 3 except logarithmic y tick marks. (The y data\n\
4667  have to be converted to logarithms separately.)\n\
4668  30: same as 0 except logarithmic x and y tick marks. (The x\n\
4669  and y data have to be converted to logarithms separately.)\n\
4670  31: same as 1 except logarithmic x and y tick marks. (The x\n\
4671  and y data have to be converted to logarithms separately.)\n\
4672  32: same as 2 except logarithmic x and y tick marks. (The x\n\
4673  and y data have to be converted to logarithms separately.)\n\
4674  33: same as 3 except logarithmic x and y tick marks. (The x\n\
4675  and y data have to be converted to logarithms separately.)\n\
4676  40: same as 0 except date / time x labels.\n\
4677  41: same as 1 except date / time x labels.\n\
4678  42: same as 2 except date / time x labels.\n\
4679  43: same as 3 except date / time x labels.\n\
4680  50: same as 0 except date / time y labels.\n\
4681  51: same as 1 except date / time y labels.\n\
4682  52: same as 2 except date / time y labels.\n\
4683  53: same as 3 except date / time y labels.\n\
4684  60: same as 0 except date / time x and y labels.\n\
4685  61: same as 1 except date / time x and y labels.\n\
4686  62: same as 2 except date / time x and y labels.\n\
4687  63: same as 3 except date / time x and y labels.\n\
4688  70: same as 0 except custom x and y labels.\n\
4689  71: same as 1 except custom x and y labels.\n\
4690  72: same as 2 except custom x and y labels.\n\
4691  73: same as 3 except custom x and y labels.\n\
4692 ";
4693 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
4694 Configure the transformations required for projecting a 3D surface on a 2D window\n\
4695 \n\
4696 DESCRIPTION:\n\
4697 \n\
4698  Configure the transformations required for projecting a 3D surface on\n\
4699  an existing 2D window. Those transformations (see the PLplot\n\
4700  documentation) are done to a rectangular cuboid enclosing the 3D\n\
4701  surface which has its limits expressed in 3D world coordinates and\n\
4702  also normalized 3D coordinates (used for interpreting the altitude and\n\
4703  azimuth of the viewing angle). The transformations consist of the\n\
4704  linear transform from 3D world coordinates to normalized 3D\n\
4705  coordinates, and the 3D rotation of normalized coordinates required to\n\
4706  align the pole of the new 3D coordinate system with the viewing\n\
4707  direction specified by altitude and azimuth so that x and y of the\n\
4708  surface elements in that transformed coordinate system are the\n\
4709  projection of the 3D surface with given viewing direction on the 2D\n\
4710  window.\n\
4711 \n\
4712  The enclosing rectangular cuboid for the surface plot is defined by\n\
4713  xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
4714  mapped into the same rectangular cuboid with normalized 3D coordinate\n\
4715  sizes of basex by basey by height so that xmin maps to -\n\
4716  basex/2, xmax maps to basex/2, ymin maps to -\n\
4717  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4718  The resulting rectangular cuboid in normalized coordinates is then\n\
4719  viewed by an observer at altitude alt and azimuth az. This routine\n\
4720  must be called before plbox3 or any of the 3D surface plotting\n\
4721  routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
4722  plsurf3dl or plfill3.\n\
4723 \n\
4724  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4725  zmin, zmax, alt, az)\n\
4726 \n\
4727  This function is examples 8, 11, 18, and 21.\n\
4728 \n\
4729 \n\
4730 \n\
4731 SYNOPSIS:\n\
4732 \n\
4733 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4734 \n\
4735 ARGUMENTS:\n\
4736 \n\
4737  basex (PLFLT, input) : The normalized x coordinate size of the\n\
4738  rectangular cuboid.\n\
4739 \n\
4740  basey (PLFLT, input) : The normalized y coordinate size of the\n\
4741  rectangular cuboid.\n\
4742 \n\
4743  height (PLFLT, input) : The normalized z coordinate size of the\n\
4744  rectangular cuboid.\n\
4745 \n\
4746  xmin (PLFLT, input) : The minimum x world coordinate of the\n\
4747  rectangular cuboid.\n\
4748 \n\
4749  xmax (PLFLT, input) : The maximum x world coordinate of the\n\
4750  rectangular cuboid.\n\
4751 \n\
4752  ymin (PLFLT, input) : The minimum y world coordinate of the\n\
4753  rectangular cuboid.\n\
4754 \n\
4755  ymax (PLFLT, input) : The maximum y world coordinate of the\n\
4756  rectangular cuboid.\n\
4757 \n\
4758  zmin (PLFLT, input) : The minimum z world coordinate of the\n\
4759  rectangular cuboid.\n\
4760 \n\
4761  zmax (PLFLT, input) : The maximum z world coordinate of the\n\
4762  rectangular cuboid.\n\
4763 \n\
4764  alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
4765  plane of the rectangular cuboid in normalized coordinates.\n\
4766 \n\
4767  az (PLFLT, input) : The viewing azimuth in degrees of the\n\
4768  rectangular cuboid in normalized coordinates. When az=0, the\n\
4769  observer is looking face onto the zx plane of the rectangular\n\
4770  cuboid in normalized coordinates, and as az is increased, the\n\
4771  observer moves clockwise around that cuboid when viewed from above\n\
4772  the xy plane.\n\
4773 ";
4774 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4775 Draw filled polygon\n\
4776 \n\
4777 DESCRIPTION:\n\
4778 \n\
4779  Fills the polygon defined by the n points (\n\
4780  x[i],\n\
4781  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4782  style is a solid fill. The routine will automatically close the\n\
4783  polygon between the last and first vertices. If multiple closed\n\
4784  polygons are passed in x and y then plfill will fill in between them.\n\
4785 \n\
4786  Redacted form: plfill(x,y)\n\
4787 \n\
4788  This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4789 \n\
4790 \n\
4791 \n\
4792 SYNOPSIS:\n\
4793 \n\
4794 plfill(n, x, y)\n\
4795 \n\
4796 ARGUMENTS:\n\
4797 \n\
4798  n (PLINT, input) : Number of vertices in polygon.\n\
4799 \n\
4800  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4801  vertices.\n\
4802 \n\
4803  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4804  vertices.\n\
4805 ";
4806 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
4807 Magnitude colored plot surface with contour\n\
4808 \n\
4809 DESCRIPTION:\n\
4810 \n\
4811  Aside from dropping the\n\
4812  side functionality this is a more powerful form of plot3d: the surface\n\
4813  mesh can be colored accordingly to the current z value being plotted,\n\
4814  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
4815  drawn between the plotted function border and the base XY plane. The\n\
4816  arguments are identical to those of plmeshc. The only difference\n\
4817  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
4818  the surface, while plot3dc only draws the surface as viewed from the\n\
4819  top.\n\
4820 \n\
4821  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
4822 \t Perl/PDL: Not available?\n\
4823 \n\
4824 \n\
4825  This function is used in example 21.\n\
4826 \n\
4827 \n\
4828 \n\
4829 SYNOPSIS:\n\
4830 \n\
4831 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4832 \n\
4833 ARGUMENTS:\n\
4834 \n\
4835  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4836  which the function is evaluated.\n\
4837 \n\
4838  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4839  which the function is evaluated.\n\
4840 \n\
4841  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4842  plot. Should have dimensions of\n\
4843  nx by\n\
4844  ny.\n\
4845 \n\
4846  nx (PLINT, input) : Number of x values at which function is\n\
4847  evaluated.\n\
4848 \n\
4849  ny (PLINT, input) : Number of y values at which function is\n\
4850  evaluated.\n\
4851 \n\
4852  opt (PLINT, input) : Determines the way in which the surface is\n\
4853  represented. To specify more than one option just add the options,\n\
4854  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
4855  showing z as a function of x for each value of y[j] .\n\
4856  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4857  for each value of x[i] .\n\
4858  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4859  at which function is defined.\n\
4860  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
4861  the z value being plotted. The color is used from the current\n\
4862  cmap1.\n\
4863  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4864  using parameters\n\
4865  nlevel and\n\
4866  clevel.\n\
4867  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4868  the borders of the plotted function.\n\
4869 \n\
4870 \n\
4871  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4872  levels.\n\
4873 \n\
4874  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4875 ";
4876 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
4877 Write text relative to viewport boundaries\n\
4878 \n\
4879 DESCRIPTION:\n\
4880 \n\
4881  Writes text at a specified position relative to the viewport\n\
4882  boundaries. Text may be written inside or outside the viewport, but\n\
4883  is clipped at the subpage boundaries. The reference point of a string\n\
4884  lies along a line passing through the string at half the height of a\n\
4885  capital letter. The position of the reference point along this line\n\
4886  is determined by just, and the position of the reference point\n\
4887  relative to the viewport is set by disp and pos.\n\
4888 \n\
4889  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4890 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4891 \n\
4892 \n\
4893  This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
4894  26.\n\
4895 \n\
4896 \n\
4897 \n\
4898 SYNOPSIS:\n\
4899 \n\
4900 plmtex(side, disp, pos, just, text)\n\
4901 \n\
4902 ARGUMENTS:\n\
4903 \n\
4904  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4905  the side of the viewport along which the text is to be written.\n\
4906  The string must be one of: b: Bottom of viewport, text written\n\
4907  parallel to edge.\n\
4908  bv: Bottom of viewport, text written at right angles to edge.\n\
4909  l: Left of viewport, text written parallel to edge.\n\
4910  lv: Left of viewport, text written at right angles to edge.\n\
4911  r: Right of viewport, text written parallel to edge.\n\
4912  rv: Right of viewport, text written at right angles to edge.\n\
4913  t: Top of viewport, text written parallel to edge.\n\
4914  tv: Top of viewport, text written at right angles to edge.\n\
4915 \n\
4916 \n\
4917  disp (PLFLT, input) : Position of the reference point of string,\n\
4918  measured outwards from the specified viewport edge in units of the\n\
4919  current character height. Use negative disp to write within the\n\
4920  viewport.\n\
4921 \n\
4922  pos (PLFLT, input) : Position of the reference point of string\n\
4923  along the specified edge, expressed as a fraction of the length of\n\
4924  the edge.\n\
4925 \n\
4926  just (PLFLT, input) : Specifies the position of the string relative\n\
4927  to its reference point. If just=0. , the reference point is at\n\
4928  the left and if just=1. , it is at the right of the string. Other\n\
4929  values of just give intermediate justifications.\n\
4930 \n\
4931  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4932  written out.\n\
4933 ";
4934 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4935 Set arrow style for vector plots\n\
4936 \n\
4937 DESCRIPTION:\n\
4938 \n\
4939  Set the style for the arrow used by plvect to plot vectors.\n\
4940 \n\
4941  Redacted form: plsvect(arrowx, arrowy, fill)\n\
4942 \n\
4943  This function is used in example 22.\n\
4944 \n\
4945 \n\
4946 \n\
4947 SYNOPSIS:\n\
4948 \n\
4949 plsvect(arrowx, arrowy, npts, fill)\n\
4950 \n\
4951 ARGUMENTS:\n\
4952 \n\
4953  arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4954  the x and y points which make up the arrow. The arrow is plotted\n\
4955  by joining these points to form a polygon. The scaling assumes\n\
4956  that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4957  <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4958  will be reset to its default.\n\
4959 \n\
4960  npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4961  arrowy.\n\
4962 \n\
4963  fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4964  fill is false then the arrow is open.\n\
4965 ";
4966 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
4967 Get family file parameters\n\
4968 \n\
4969 DESCRIPTION:\n\
4970 \n\
4971  Gets information about current family file, if familying is enabled.\n\
4972  See the PLplot documentation for more information.\n\
4973 \n\
4974  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
4975 \n\
4976  This function is used in examples 14 and 31.\n\
4977 \n\
4978 \n\
4979 \n\
4980 SYNOPSIS:\n\
4981 \n\
4982 plgfam(p_fam, p_num, p_bmax)\n\
4983 \n\
4984 ARGUMENTS:\n\
4985 \n\
4986  p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
4987  family flag value. If nonzero, familying is enabled for the\n\
4988  current device.\n\
4989 \n\
4990  p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
4991  family file number.\n\
4992 \n\
4993  p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4994  file size (in bytes) for a family file.\n\
4995 ";
4996 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
4997 Random number generator returning a real random number in the range [0,1]\n\
4998 \n\
4999 DESCRIPTION:\n\
5000 \n\
5001  Random number generator returning a real random number in the range\n\
5002  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5003  / compilers provide their own random number generator, and so this is\n\
5004  provided purely for convenience and to give a consistent random number\n\
5005  generator across all languages supported by PLplot. This is\n\
5006  particularly useful for comparing results from the test suite of\n\
5007  examples.\n\
5008 \n\
5009  Redacted form: plrandd()\n\
5010 \n\
5011  This function is used in examples 17 and 21.\n\
5012 \n\
5013 \n\
5014 \n\
5015 SYNOPSIS:\n\
5016 \n\
5017 plrandd()\n\
5018 ";
5019 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5020 Contour plot\n\
5021 \n\
5022 DESCRIPTION:\n\
5023 \n\
5024  Draws a contour plot of the data in f[\n\
5025  nx][\n\
5026  ny], using the nlevel contour levels specified by clevel. Only the\n\
5027  region of the matrix from kx to lx and from ky to ly is plotted out\n\
5028  where all these index ranges are interpreted as one-based for\n\
5029  historical reasons. A transformation routine pointed to by pltr with\n\
5030  a generic pointer pltr_data for additional data required by the\n\
5031  transformation routine is used to map indices within the matrix to the\n\
5032  world coordinates.\n\
5033 \n\
5034  Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5035  where (see above discussion) the pltr, pltr_data callback arguments\n\
5036  are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5037  vectors; or xg and yg matrices.\n\
5038 \n\
5039  This function is used in examples 9, 14, 16, and 22.\n\
5040 \n\
5041 \n\
5042 \n\
5043 SYNOPSIS:\n\
5044 \n\
5045 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5046 \n\
5047 ARGUMENTS:\n\
5048 \n\
5049  f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5050 \n\
5051  nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5052 \n\
5053  kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5054  kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5055  zero-based for historical backwards-compatibility reasons.\n\
5056 \n\
5057  ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5058  ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5059  zero-based for historical backwards-compatibility reasons.\n\
5060 \n\
5061  clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5062  which to draw contours.\n\
5063 \n\
5064  nlevel (PLINT, input) : Number of contour levels to draw.\n\
5065 \n\
5066  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5067  defines the transformation between the zero-based indices of the\n\
5068  matrix f and the world coordinates.For the C case, transformation\n\
5069  functions are provided in the PLplot library: pltr0 for the\n\
5070  identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5071  respectively defined by vectors and matrices. In addition, C\n\
5072  callback routines for the transformation can be supplied by the\n\
5073  user such as the mypltr function in examples/c/x09c.c which\n\
5074  provides a general linear transformation between index coordinates\n\
5075  and world coordinates.For languages other than C you should\n\
5076  consult the PLplot documentation for the details concerning how\n\
5077  PLTRANSFORM_callback arguments are interfaced. However, in\n\
5078  general, a particular pattern of callback-associated arguments\n\
5079  such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5080  yg matrices are respectively interfaced to a linear-transformation\n\
5081  routine similar to the above mypltr function; pltr1; and pltr2.\n\
5082  Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5083  the PLplot documentation) support native language callbacks for\n\
5084  handling index to world-coordinate transformations. Examples of\n\
5085  these various approaches are given in examples/<language>x09*,\n\
5086  examples/<language>x16*, examples/<language>x20*,\n\
5087  examples/<language>x21*, and examples/<language>x22*, for all our\n\
5088  supported languages.\n\
5089 \n\
5090  pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
5091  pass information to pltr0, pltr1, pltr2, or whatever callback\n\
5092  routine that is externally supplied.\n\
5093 ";
5094 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5095 Set line style\n\
5096 \n\
5097 DESCRIPTION:\n\
5098 \n\
5099  This sets up the line style for all lines subsequently drawn. A line\n\
5100  consists of segments in which the pen is alternately down and up. The\n\
5101  lengths of these segments are passed in the vectors mark and space\n\
5102  respectively. The number of mark-space pairs is specified by nms.\tIn\n\
5103  order to return the line style to the default continuous line, plstyl\n\
5104  should be called with nms =0 .(see also pllsty)\n\
5105 \n\
5106  Redacted form: plstyl(mark, space)\n\
5107 \n\
5108  This function is used in examples 1, 9, and 14.\n\
5109 \n\
5110 \n\
5111 \n\
5112 SYNOPSIS:\n\
5113 \n\
5114 plstyl(nms, mark, space)\n\
5115 \n\
5116 ARGUMENTS:\n\
5117 \n\
5118  nms (PLINT, input) : The number of mark and space elements in a\n\
5119  line. Thus a simple broken line can be obtained by setting nms=1\n\
5120  . A continuous line is specified by setting nms=0 .\n\
5121 \n\
5122  mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5123  segments during which the pen is down, measured in micrometers.\n\
5124 \n\
5125  space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5126  the segments during which the pen is up, measured in micrometers.\n\
5127 ";
5128 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5129 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5130 \n\
5131 DESCRIPTION:\n\
5132 \n\
5133  Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5134 \n\
5135  Redacted form: plspal0(filename)\n\
5136 \n\
5137  This function is in example 16.\n\
5138 \n\
5139 \n\
5140 \n\
5141 SYNOPSIS:\n\
5142 \n\
5143 plspal0(filename)\n\
5144 \n\
5145 ARGUMENTS:\n\
5146 \n\
5147  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5148  containing the name of the cmap0*.pal file. If this string is\n\
5149  empty, use the default cmap0*.pal file.\n\
5150 ";
5151 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5152 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5153 \n\
5154 DESCRIPTION:\n\
5155 \n\
5156  Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5157 \n\
5158  Redacted form: plspal1(filename, interpolate)\n\
5159 \n\
5160  This function is used in example 16.\n\
5161 \n\
5162 \n\
5163 \n\
5164 SYNOPSIS:\n\
5165 \n\
5166 plspal1(filename, interpolate)\n\
5167 \n\
5168 ARGUMENTS:\n\
5169 \n\
5170  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5171  containing the name of the cmap1*.pal file. If this string is\n\
5172  empty, use the default cmap1*.pal file.\n\
5173 \n\
5174  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5175  columns containing the intensity index, r, g, b, alpha and\n\
5176  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5177  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5178  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5179  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5180  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5181  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5182  are used instead to set the cmap1 palette directly with a call to\n\
5183  plscmap1a.\n\
5184 ";
5185 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5186 Set current output stream\n\
5187 \n\
5188 DESCRIPTION:\n\
5189 \n\
5190  Sets the number of the current output stream. The stream number\n\
5191  defaults to 0 unless changed by this routine. The first use of this\n\
5192  routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5193 \n\
5194  Redacted form: plsstrm(strm)\n\
5195 \n\
5196  This function is examples 1,14,20.\n\
5197 \n\
5198 \n\
5199 \n\
5200 SYNOPSIS:\n\
5201 \n\
5202 plsstrm(strm)\n\
5203 \n\
5204 ARGUMENTS:\n\
5205 \n\
5206  strm (PLINT, input) : The current stream number.\n\
5207 ";
5208 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5209 Specify viewport using normalized subpage coordinates\n\
5210 \n\
5211 DESCRIPTION:\n\
5212 \n\
5213  Device-independent routine for setting up the viewport. This defines\n\
5214  the viewport in terms of normalized subpage coordinates which run from\n\
5215  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5216  current subpage. Use the alternate routine plsvpa in order to create\n\
5217  a viewport of a definite size.\n\
5218 \n\
5219  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5220 \n\
5221  This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5222  24, 26, 27, and 31.\n\
5223 \n\
5224 \n\
5225 \n\
5226 SYNOPSIS:\n\
5227 \n\
5228 plvpor(xmin, xmax, ymin, ymax)\n\
5229 \n\
5230 ARGUMENTS:\n\
5231 \n\
5232  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5233  left-hand edge of the viewport.\n\
5234 \n\
5235  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5236  right-hand edge of the viewport.\n\
5237 \n\
5238  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5239  bottom edge of the viewport.\n\
5240 \n\
5241  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5242  edge of the viewport.\n\
5243 ";
5244 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5245 Write text inside the viewport\n\
5246 \n\
5247 DESCRIPTION:\n\
5248 \n\
5249  Writes text at a specified position and inclination within the\n\
5250  viewport. Text is clipped at the viewport boundaries. The reference\n\
5251  point of a string lies along a line passing through the string at half\n\
5252  the height of a capital letter. The position of the reference point\n\
5253  along this line is determined by just, the reference point is placed\n\
5254  at world coordinates (\n\
5255  x,\n\
5256  y)\twithin the viewport. The inclination of the string is specified\n\
5257  in terms of differences of world coordinates making it easy to write\n\
5258  text parallel to a line in a graph.\n\
5259 \n\
5260  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5261 \n\
5262  This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5263 \n\
5264 \n\
5265 \n\
5266 SYNOPSIS:\n\
5267 \n\
5268 plptex(x, y, dx, dy, just, text)\n\
5269 \n\
5270 ARGUMENTS:\n\
5271 \n\
5272  x (PLFLT, input) : x coordinate of reference point of string.\n\
5273 \n\
5274  y (PLFLT, input) : y coordinate of reference point of string.\n\
5275 \n\
5276  dx (PLFLT, input) : Together with dy, this specifies the\n\
5277  inclination of the string. The baseline of the string is parallel\n\
5278  to a line joining (\n\
5279  x,\n\
5280  y) to (\n\
5281  x+\n\
5282  dx,\n\
5283  y+\n\
5284  dy) .\n\
5285 \n\
5286  dy (PLFLT, input) : Together with dx, this specifies the\n\
5287  inclination of the string.\n\
5288 \n\
5289  just (PLFLT, input) : Specifies the position of the string relative\n\
5290  to its reference point. If just=0. , the reference point is at\n\
5291  the left and if just=1. , it is at the right of the string. Other\n\
5292  values of just give intermediate justifications.\n\
5293 \n\
5294  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5295  written out.\n\
5296 ";
5297 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5298 Set z axis parameters\n\
5299 \n\
5300 DESCRIPTION:\n\
5301 \n\
5302  Identical to plsxax, except that arguments are flags for z axis. See\n\
5303  the description of plsxax for more detail.\n\
5304 \n\
5305  Redacted form: plszax(digmax, digits)\n\
5306 \n\
5307  This function is used in example 31.\n\
5308 \n\
5309 \n\
5310 \n\
5311 SYNOPSIS:\n\
5312 \n\
5313 plszax(digmax, digits)\n\
5314 \n\
5315 ARGUMENTS:\n\
5316 \n\
5317  digmax (PLINT, input) : Variable to set the maximum number of\n\
5318  digits for the z axis. If nonzero, the printed label will be\n\
5319  switched to a floating-point representation when the number of\n\
5320  digits exceeds digmax.\n\
5321 \n\
5322  digits (PLINT, input) : Field digits value. Currently, changing\n\
5323  its value here has no effect since it is set only by plbox or\n\
5324  plbox3. However, the user may obtain its value after a call to\n\
5325  either of these functions by calling plgzax.\n\
5326 ";
5327 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5328 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5329 \n\
5330 DESCRIPTION:\n\
5331 \n\
5332  This variant of plsurf3d (see that function\'s documentation for more\n\
5333  details) should be suitable for the case where the area of the x, y\n\
5334  coordinate grid where z is defined can be non-rectangular.\tThe limits\n\
5335  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5336  indexymin, and indexymax.\n\
5337 \n\
5338  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5339  indexymax)\n\
5340 \n\
5341  This function is used in example 8.\n\
5342 \n\
5343 \n\
5344 \n\
5345 SYNOPSIS:\n\
5346 \n\
5347 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5348 \n\
5349 ARGUMENTS:\n\
5350 \n\
5351  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5352  which the function is evaluated.\n\
5353 \n\
5354  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5355  which the function is evaluated.\n\
5356 \n\
5357  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5358  plot. Should have dimensions of\n\
5359  nx by\n\
5360  ny.\n\
5361 \n\
5362  nx (PLINT, input) : Number of x values at which function is\n\
5363  evaluated.\n\
5364 \n\
5365  ny (PLINT, input) : Number of y values at which function is\n\
5366  evaluated.\n\
5367 \n\
5368  opt (PLINT, input) : Determines the way in which the surface is\n\
5369  represented. To specify more than one option just add the options,\n\
5370  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5371  connecting points at which function is defined.\n\
5372  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5373  using parameters\n\
5374  nlevel and\n\
5375  clevel.\n\
5376  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5377  using parameters\n\
5378  nlevel and\n\
5379  clevel.\n\
5380  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5381  the borders of the plotted function.\n\
5382  opt=MAG_COLOR : the surface is colored according to the value\n\
5383  of Z; if MAG_COLOR is not used, then the surface is colored\n\
5384  according to the intensity of the reflected light in the\n\
5385  surface from a light source whose position is set using\n\
5386  pllightsource.\n\
5387 \n\
5388 \n\
5389  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5390  levels.\n\
5391 \n\
5392  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5393 \n\
5394  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5395  corresponds to the first x index where z is defined.\n\
5396 \n\
5397  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5398  which corresponds (by convention) to one more than the last x\n\
5399  index value where z is defined.\n\
5400 \n\
5401  indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5402  values which all must be ≥ 0. These values are the first y index\n\
5403  where z is defined for a particular x index in the range from\n\
5404  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5405  indexxmax.\n\
5406 \n\
5407  indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5408  values which all must be ≤ ny. These values correspond (by\n\
5409  convention) to one more than the last y index where z is defined\n\
5410  for a particular x index in the range from indexxmin to indexxmax\n\
5411  - 1. The dimension of indexymax is indexxmax.\n\
5412 ";
5413 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5414 Set font\n\
5415 \n\
5416 DESCRIPTION:\n\
5417 \n\
5418  Sets the font used for subsequent text and symbols. For devices that\n\
5419  still use Hershey fonts this routine has no effect unless the Hershey\n\
5420  fonts with extended character set are loaded (see plfontld). For\n\
5421  unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5422  this routine calls the plsfci routine with argument set up\n\
5423  appropriately for the various cases below.\tHowever, this method of\n\
5424  specifying the font for unicode-aware devices is deprecated, and the\n\
5425  much more flexible method of calling plsfont directly is recommended\n\
5426  instead (where plsfont provides a user-friendly interface to plsfci),\n\
5427 \n\
5428  Redacted form: plfont(ifont)\n\
5429 \n\
5430  This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5431 \n\
5432 \n\
5433 \n\
5434 SYNOPSIS:\n\
5435 \n\
5436 plfont(ifont)\n\
5437 \n\
5438 ARGUMENTS:\n\
5439 \n\
5440  ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5441  (simplest and fastest)\n\
5442  2: Serif font\n\
5443  3: Italic font\n\
5444  4: Script font\n\
5445 ";
5446 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5447 Get the cmap1 argument range for continuous color plots\n\
5448 \n\
5449 DESCRIPTION:\n\
5450 \n\
5451  Get the cmap1 argument range for continuous color plots. (Use\n\
5452  plscmap1_range to set the cmap1 argument range.)\n\
5453 \n\
5454  Redacted form: plgcmap1_range(min_color, max_color)\n\
5455 \n\
5456  This function is currently not used in any example.\n\
5457 \n\
5458 \n\
5459 \n\
5460 SYNOPSIS:\n\
5461 \n\
5462 plgcmap1_range(min_color, max_color)\n\
5463 \n\
5464 ARGUMENTS:\n\
5465 \n\
5466  min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5467  minimum cmap1 argument.\n\
5468 \n\
5469  max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5470  maximum cmap1 argument.\n\
5471 ";
5472 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5473 Set the cmap1 argument range for continuous color plots\n\
5474 \n\
5475 DESCRIPTION:\n\
5476 \n\
5477  Set the cmap1 argument range for continuous color plots that\n\
5478  corresponds to the range of data values. The maximum range\n\
5479  corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5480  the cmap1 argument range that is specified with this routine, the\n\
5481  smaller the subset of the cmap1 color palette that is used to\n\
5482  represent the continuous data being plotted. If\n\
5483  min_color is greater than\n\
5484  max_color or\n\
5485  max_color is greater than 1.0 or\n\
5486  min_color is less than 0.0 then no change is made to the cmap1\n\
5487  argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5488 \n\
5489  Redacted form: plscmap1_range(min_color, max_color)\n\
5490 \n\
5491  This function is currently used in example 33.\n\
5492 \n\
5493 \n\
5494 \n\
5495 SYNOPSIS:\n\
5496 \n\
5497 plscmap1_range(min_color, max_color)\n\
5498 \n\
5499 ARGUMENTS:\n\
5500 \n\
5501  min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5502  than 0.0, then 0.0 is used instead.\n\
5503 \n\
5504  max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5505  than 1.0, then 1.0 is used instead.\n\
5506 ";
5507 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5508 Draw a circular or elliptical arc\n\
5509 \n\
5510 DESCRIPTION:\n\
5511 \n\
5512  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5513  semiminor axis b, starting at angle1 and ending at angle2.\n\
5514 \n\
5515  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5516  fill)\n\
5517 \n\
5518 \n\
5519  This function is used in examples 3 and 27.\n\
5520 \n\
5521 \n\
5522 \n\
5523 SYNOPSIS:\n\
5524 \n\
5525 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5526 \n\
5527 ARGUMENTS:\n\
5528 \n\
5529  x (PLFLT, input) : X coordinate of arc center.\n\
5530 \n\
5531  y (PLFLT, input) : Y coordinate of arc center.\n\
5532 \n\
5533  a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5534 \n\
5535  b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5536 \n\
5537  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5538  semimajor axis.\n\
5539 \n\
5540  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5541  semimajor axis.\n\
5542 \n\
5543  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5544  X-axis.\n\
5545 \n\
5546  fill (PLBOOL, input) : Draw a filled arc.\n\
5547 ";
5548 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5549 Plot 3-d surface plot\n\
5550 \n\
5551 DESCRIPTION:\n\
5552 \n\
5553  Plots a three-dimensional surface plot within the environment set up\n\
5554  by plw3d. The surface is defined by the matrix z[\n\
5555  nx][\n\
5556  ny] , the point z[i][j] being the value of the function at (\n\
5557  x[i],\n\
5558  y[j]). Note that the points in vectors x and y do not need to be\n\
5559  equally spaced, but must be stored in ascending order. The parameter\n\
5560  opt controls the way in which the surface is displayed. For further\n\
5561  details see the PLplot documentation. The only difference between\n\
5562  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5563  while plot3d only draws the surface as viewed from the top.\n\
5564 \n\
5565  Redacted form: plot3d(x, y, z, opt, side)\n\
5566 \n\
5567  This function is used in examples 11 and 21.\n\
5568 \n\
5569 \n\
5570 \n\
5571 SYNOPSIS:\n\
5572 \n\
5573 plot3d(x, y, z, nx, ny, opt, side)\n\
5574 \n\
5575 ARGUMENTS:\n\
5576 \n\
5577  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5578  which the function is evaluated.\n\
5579 \n\
5580  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5581  which the function is evaluated.\n\
5582 \n\
5583  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5584  plot. Should have dimensions of\n\
5585  nx by\n\
5586  ny.\n\
5587 \n\
5588  nx (PLINT, input) : Number of x values at which function is\n\
5589  evaluated.\n\
5590 \n\
5591  ny (PLINT, input) : Number of y values at which function is\n\
5592  evaluated.\n\
5593 \n\
5594  opt (PLINT, input) : Determines the way in which the surface is\n\
5595  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5596  function of x for each value of y[j] .\n\
5597  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5598  for each value of x[i] .\n\
5599  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5600  at which function is defined.\n\
5601 \n\
5602 \n\
5603  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5604  should be draw on the figure. If side is true sides are drawn,\n\
5605  otherwise no sides are drawn.\n\
5606 ";
5607 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5608 Set area line fill pattern\n\
5609 \n\
5610 DESCRIPTION:\n\
5611 \n\
5612  Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5613  The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5614  inclinations and spacings.\tThe arguments to this routine are the\n\
5615  number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5616  elements) specifying the inclinations in tenths of a degree and the\n\
5617  spacing in micrometers. (See also plpsty)\n\
5618 \n\
5619  Redacted form: General: plpat(inc, del)\n\
5620 \t Perl/PDL: plpat(nlin, inc, del)\n\
5621 \n\
5622 \n\
5623  This function is used in example 15.\n\
5624 \n\
5625 \n\
5626 \n\
5627 SYNOPSIS:\n\
5628 \n\
5629 plpat(nlin, inc, del)\n\
5630 \n\
5631 ARGUMENTS:\n\
5632 \n\
5633  nlin (PLINT, input) : Number of sets of lines making up the\n\
5634  pattern, either 1 or 2.\n\
5635 \n\
5636  inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5637  inclination in tenths of a degree. (Should be between -900 and\n\
5638  900).\n\
5639 \n\
5640  del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5641  spacing in micrometers between the lines making up the pattern.\n\
5642 ";
5643 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
5644 Get x axis parameters\n\
5645 \n\
5646 DESCRIPTION:\n\
5647 \n\
5648  Returns current values of the p_digmax and p_digits flags for the x\n\
5649  axis. p_digits is updated after the plot is drawn, so this routine\n\
5650  should only be called after the call to plbox (or plbox3) is complete.\n\
5651  See the PLplot documentation for more information.\n\
5652 \n\
5653  Redacted form: plgxax(p_digmax, p_digits)\n\
5654 \n\
5655  This function is used in example 31.\n\
5656 \n\
5657 \n\
5658 \n\
5659 SYNOPSIS:\n\
5660 \n\
5661 plgxax(p_digmax, p_digits)\n\
5662 \n\
5663 ARGUMENTS:\n\
5664 \n\
5665  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5666  number of digits for the x axis. If nonzero, the printed label\n\
5667  has been switched to a floating-point representation when the\n\
5668  number of digits exceeds this value.\n\
5669 \n\
5670  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5671  number of digits for the numeric labels (x axis) from the last\n\
5672  plot.\n\
5673 ";
5674 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
5675 Draw filled polygon in 3D\n\
5676 \n\
5677 DESCRIPTION:\n\
5678 \n\
5679  Fills the 3D polygon defined by the n points in the x, y, and z\n\
5680  vectors using the pattern defined by plpsty or plpat. The routine\n\
5681  will automatically close the polygon between the last and first\n\
5682  vertices. If multiple closed polygons are passed in x, y, and z then\n\
5683  plfill3 will fill in between them.\n\
5684 \n\
5685  Redacted form: General: plfill3(x, y, z)\n\
5686 \t Perl/PDL: plfill3(n, x, y, z)\n\
5687 \n\
5688 \n\
5689  This function is used in example 15.\n\
5690 \n\
5691 \n\
5692 \n\
5693 SYNOPSIS:\n\
5694 \n\
5695 plfill3(n, x, y, z)\n\
5696 \n\
5697 ARGUMENTS:\n\
5698 \n\
5699  n (PLINT, input) : Number of vertices in polygon.\n\
5700 \n\
5701  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5702  vertices.\n\
5703 \n\
5704  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5705  vertices.\n\
5706 \n\
5707  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5708  vertices.\n\
5709 ";
5710 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
5711 Set color, cmap0\n\
5712 \n\
5713 DESCRIPTION:\n\
5714 \n\
5715  Sets the color index for cmap0 (see the PLplot documentation).\n\
5716 \n\
5717  Redacted form: plcol0(icol0)\n\
5718 \n\
5719  This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
5720 \n\
5721 \n\
5722 \n\
5723 SYNOPSIS:\n\
5724 \n\
5725 plcol0(icol0)\n\
5726 \n\
5727 ARGUMENTS:\n\
5728 \n\
5729  icol0 (PLINT, input) : Integer representing the color. The\n\
5730  defaults at present are (these may change):\n\
5731  0 black (default background)\n\
5732  1 red (default foreground)\n\
5733  2 yellow\n\
5734  3 green\n\
5735  4 aquamarine\n\
5736  5 pink\n\
5737  6 wheat\n\
5738  7 grey\n\
5739  8 brown\n\
5740  9 blue\n\
5741  10 BlueViolet\n\
5742  11 cyan\n\
5743  12 turquoise\n\
5744  13 magenta\n\
5745  14 salmon\n\
5746  15 white\n\
5747 \n\
5748  Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
5749  change an individual color in the cmap0 color palette.\n\
5750 ";
5751 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
5752 Draw text at points defined by Shapefile data in world coordinates\n\
5753 \n\
5754 DESCRIPTION:\n\
5755 \n\
5756  As per plmapline, however the items are plotted as text in the same\n\
5757  way as plptex.\n\
5758 \n\
5759  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
5760  miny, maxy, plotentry)\n\
5761 \n\
5762  This function is used in example 19.\n\
5763 \n\
5764 \n\
5765 \n\
5766 SYNOPSIS:\n\
5767 \n\
5768 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
5769 \n\
5770 ARGUMENTS:\n\
5771 \n\
5772  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5773  transform the coordinates given in the shapefile into a plot\n\
5774  coordinate system. By using this transform, we can change from a\n\
5775  longitude, latitude coordinate to a polar stereographic project,\n\
5776  for example. Initially, x[0]..[n-1] are the longitudes and\n\
5777  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5778  mapform(), x[] and y[] should be replaced by the corresponding\n\
5779  plot coordinates. If no transform is desired, mapform can be\n\
5780  replaced by NULL.\n\
5781 \n\
5782  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5783  the file name of a set of Shapefile files without the file\n\
5784  extension.\n\
5785 \n\
5786  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
5787  dy/dx.\n\
5788 \n\
5789  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
5790  dy/dx.\n\
5791 \n\
5792  just (PLFLT, input) : Set the justification of the text. The value\n\
5793  given will be the fraction of the distance along the string that\n\
5794  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
5795  centralized text and 1.0 gives right aligned text.\n\
5796 \n\
5797  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
5798 \n\
5799  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5800  be in the same units as used by the Shapefile. You could use a\n\
5801  very large negative number to plot everything, but you can improve\n\
5802  performance by limiting the area drawn. The units must match those\n\
5803  of the Shapefile projection, which may be for example longitude or\n\
5804  distance. The value of minx must be less than the value of maxx.\n\
5805 \n\
5806  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5807  use a very large number to plot everything, but you can improve\n\
5808  performance by limiting the area drawn.\n\
5809 \n\
5810  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5811  be in the same units as used by the Shapefile. You could use a\n\
5812  very large negative number to plot everything, but you can improve\n\
5813  performance by limiting the area drawn. The units must match those\n\
5814  of the Shapefile projection, which may be for example latitude or\n\
5815  distance. The value of miny must be less than the value of maxy.\n\
5816 \n\
5817  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5818  use a very large number to plot everything, but you can improve\n\
5819  performance by limiting the area drawn.\n\
5820 \n\
5821  plotentry (PLINT, input) : An integer indicating which text string\n\
5822  of the Shapefile (zero indexed) will be drawn.\n\
5823 ";
5824 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
5825 Draw a line between two points\n\
5826 \n\
5827 DESCRIPTION:\n\
5828 \n\
5829  Joins the point (\n\
5830  x1,\n\
5831  y1) to (\n\
5832  x2,\n\
5833  y2).\n\
5834 \n\
5835  Redacted form: pljoin(x1,y1,x2,y2)\n\
5836 \n\
5837  This function is used in examples 3 and 14.\n\
5838 \n\
5839 \n\
5840 \n\
5841 SYNOPSIS:\n\
5842 \n\
5843 pljoin(x1, y1, x2, y2)\n\
5844 \n\
5845 ARGUMENTS:\n\
5846 \n\
5847  x1 (PLFLT, input) : x coordinate of first point.\n\
5848 \n\
5849  y1 (PLFLT, input) : y coordinate of first point.\n\
5850 \n\
5851  x2 (PLFLT, input) : x coordinate of second point.\n\
5852 \n\
5853  y2 (PLFLT, input) : y coordinate of second point.\n\
5854 ";
5855 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
5856 Set color, cmap1\n\
5857 \n\
5858 DESCRIPTION:\n\
5859 \n\
5860  Sets the color for cmap1 (see the PLplot documentation).\n\
5861 \n\
5862  Redacted form: plcol1(col1)\n\
5863 \n\
5864  This function is used in examples 12 and 21.\n\
5865 \n\
5866 \n\
5867 \n\
5868 SYNOPSIS:\n\
5869 \n\
5870 plcol1(col1)\n\
5871 \n\
5872 ARGUMENTS:\n\
5873 \n\
5874  col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
5875  is mapped to color using the continuous cmap1 palette which by\n\
5876  default ranges from blue to the background color to red. The\n\
5877  cmap1 palette can also be straightforwardly changed by the user\n\
5878  with plscmap1 or plscmap1l.\n\
5879 ";
5880 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
5881 Set orientation\n\
5882 \n\
5883 DESCRIPTION:\n\
5884 \n\
5885  Set integer plot orientation parameter. This function is identical to\n\
5886  plsdiori except for the type of the argument, and should be used in\n\
5887  the same way. See the documentation of plsdiori for details.\n\
5888 \n\
5889  Redacted form: plsori(ori)\n\
5890 \n\
5891  This function is used in example 3.\n\
5892 \n\
5893 \n\
5894 \n\
5895 SYNOPSIS:\n\
5896 \n\
5897 plsori(ori)\n\
5898 \n\
5899 ARGUMENTS:\n\
5900 \n\
5901  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5902  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5903  angle.\n\
5904 ";
5905 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
5906 Calculate continuous time from broken-down time for the current stream\n\
5907 \n\
5908 DESCRIPTION:\n\
5909 \n\
5910  Calculate continuous time, ctime, from broken-down time for the\n\
5911  current stream. The broken-down\n\
5912  time is specified by the following parameters: year, month, day, hour,\n\
5913  min, and sec. This function is the inverse of plbtime.\n\
5914 \n\
5915  The PLplot definition of broken-down time is a calendar time that\n\
5916  completely ignores all time zone offsets, i.e., it is the user\'s\n\
5917  responsibility to apply those offsets (if so desired) before using the\n\
5918  PLplot time API. By default broken-down time is defined using the\n\
5919  proleptic Gregorian calendar without the insertion of leap seconds and\n\
5920  continuous time is defined as the number of seconds since the Unix\n\
5921  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
5922  broken-down and continuous time are possible, see plconfigtime which\n\
5923  specifies that transformation for the current stream.\n\
5924 \n\
5925  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
5926  ctime)\n\
5927 \t Perl/PDL: Not available?\n\
5928 \n\
5929 \n\
5930  This function is used in example 29.\n\
5931 \n\
5932 \n\
5933 \n\
5934 SYNOPSIS:\n\
5935 \n\
5936 plctime(year, month, day, hour, min, sec, ctime)\n\
5937 \n\
5938 ARGUMENTS:\n\
5939 \n\
5940  year (PLINT, input) : Input year.\n\
5941 \n\
5942  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
5943  (December).\n\
5944 \n\
5945  day (PLINT, input) : Input day in range from 1 to 31.\n\
5946 \n\
5947  hour (PLINT, input) : Input hour in range from 0 to 23\n\
5948 \n\
5949  min (PLINT, input) : Input minute in range from 0 to 59.\n\
5950 \n\
5951  sec (PLFLT, input) : Input second in range from 0. to 60.\n\
5952 \n\
5953  ctime (PLFLT_NC_SCALAR, output) : Returned value of the continous\n\
5954  time calculated from the broken-down time specified by the\n\
5955  previous parameters.\n\
5956 ";
5957 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5958 Plot continental outline or shapefile data in world coordinates\n\
5959 \n\
5960 DESCRIPTION:\n\
5961 \n\
5962  Plots continental outlines or shapefile data in world coordinates. A\n\
5963  demonstration of how to use this function to create different\n\
5964  projections can be found in examples/c/x19c. PLplot is provided with\n\
5965  basic coastal outlines and USA state borders. These can be used\n\
5966  irrespective of whether Shapefile support is built into PLplot. With\n\
5967  Shapefile support this function can also be used with user Shapefiles,\n\
5968  in which case it will plot the entire contents of a Shapefile joining\n\
5969  each point of each Shapefile element with a line. Shapefiles have\n\
5970  become a popular standard for geographical data and data in this\n\
5971  format can be easily found from a number of online sources. Shapefile\n\
5972  data is actually provided as three or more files with the same\n\
5973  filename, but different extensions. The .shp and .shx files are\n\
5974  required for plotting Shapefile data with PLplot.\n\
5975 \n\
5976  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5977 \n\
5978  This function is used in example 19.\n\
5979 \n\
5980 \n\
5981 \n\
5982 SYNOPSIS:\n\
5983 \n\
5984 plmap(mapform, name, minx, maxx, miny, maxy)\n\
5985 \n\
5986 ARGUMENTS:\n\
5987 \n\
5988  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5989  transform the original map data coordinates to a new coordinate\n\
5990  system. The PLplot-supplied map data is provided as latitudes and\n\
5991  longitudes; other Shapefile data may be provided in other\n\
5992  coordinate systems as can be found in their .prj plain text files.\n\
5993  For example, by using this transform we can change from a\n\
5994  longitude, latitude coordinate to a polar stereographic\n\
5995  projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5996  (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5997  corresponding y coordinates (latitudes for the PLplot supplied\n\
5998  data). After the call to mapform(), x[] and y[] should be\n\
5999  replaced by the corresponding plot coordinates. If no transform is\n\
6000  desired, mapform can be replaced by NULL.\n\
6001 \n\
6002  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6003  the type of map plotted. This is either one of the PLplot built-in\n\
6004  maps or the file name of a set of Shapefile files without the file\n\
6005  extensions. For the PLplot built-in maps the possible values are:\n\
6006  \"globe\" -- continental outlines\n\
6007  \"usa\" -- USA and state boundaries\n\
6008  \"cglobe\" -- continental outlines and countries\n\
6009  \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6010 \n\
6011 \n\
6012  minx (PLFLT, input) : The minimum x value of map elements to be\n\
6013  drawn. For the built in maps this is a measure of longitude. For\n\
6014  Shapefiles the units must match the projection. The value of minx\n\
6015  must be less than the value of maxx. Specifying a useful limit for\n\
6016  these limits provides a useful optimization for complex or\n\
6017  detailed maps.\n\
6018 \n\
6019  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6020  drawn\n\
6021 \n\
6022  miny (PLFLT, input) : The minimum y value of map elements to be\n\
6023  drawn. For the built in maps this is a measure of latitude. For\n\
6024  Shapefiles the units must match the projection. The value of miny\n\
6025  must be less than the value of maxy.\n\
6026 \n\
6027  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6028  drawn.\n\
6029 ";
6030 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6031 Calculate broken-down time from continuous time for the current stream\n\
6032 \n\
6033 DESCRIPTION:\n\
6034 \n\
6035  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6036  continuous time, ctime for the current stream. This function is the\n\
6037  inverse of plctime.\n\
6038 \n\
6039  The PLplot definition of broken-down time is a calendar time that\n\
6040  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6041  responsibility to apply those offsets (if so desired) before using the\n\
6042  PLplot time API. By default broken-down time is defined using the\n\
6043  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6044  continuous time is defined as the number of seconds since the Unix\n\
6045  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6046  broken-down and continuous time are possible, see plconfigtime.\n\
6047 \n\
6048  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6049  ctime)\n\
6050 \t Perl/PDL: Not available?\n\
6051 \n\
6052 \n\
6053  This function is used in example 29.\n\
6054 \n\
6055 \n\
6056 \n\
6057 SYNOPSIS:\n\
6058 \n\
6059 plbtime(year, month, day, hour, min, sec, ctime)\n\
6060 \n\
6061 ARGUMENTS:\n\
6062 \n\
6063  year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6064  positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6065  non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6066  BCE, etc.)\n\
6067 \n\
6068  month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6069  the year in the range from 0 (January) to 11 (December).\n\
6070 \n\
6071  day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6072  month in the range from 1 to 31.\n\
6073 \n\
6074  hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6075  day in the range from 0 to 23.\n\
6076 \n\
6077  min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6078  hour in the range from 0 to 59\n\
6079 \n\
6080  sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6081  minute in range from 0. to 60.\n\
6082 \n\
6083  ctime (PLFLT, input) : Continous time from which the broken-down\n\
6084  time is calculated.\n\
6085 ";
6086 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6087 Get current stream number\n\
6088 \n\
6089 DESCRIPTION:\n\
6090 \n\
6091  Gets the number of the current output stream. See also plsstrm.\n\
6092 \n\
6093  Redacted form: plgstrm(p_strm)\n\
6094 \n\
6095  This function is used in example 1,20.\n\
6096 \n\
6097 \n\
6098 \n\
6099 SYNOPSIS:\n\
6100 \n\
6101 plgstrm(p_strm)\n\
6102 \n\
6103 ARGUMENTS:\n\
6104 \n\
6105  p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6106  stream value.\n\
6107 ";
6108 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6109 Draw a line in 3 space\n\
6110 \n\
6111 DESCRIPTION:\n\
6112 \n\
6113  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6114  first set up the viewport, the 2d viewing window (in world\n\
6115  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6116  more info.\n\
6117 \n\
6118  Redacted form: plline3(x, y, z)\n\
6119 \n\
6120  This function is used in example 18.\n\
6121 \n\
6122 \n\
6123 \n\
6124 SYNOPSIS:\n\
6125 \n\
6126 plline3(n, x, y, z)\n\
6127 \n\
6128 ARGUMENTS:\n\
6129 \n\
6130  n (PLINT, input) : Number of points defining line.\n\
6131 \n\
6132  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6133  points.\n\
6134 \n\
6135  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6136  points.\n\
6137 \n\
6138  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6139  points.\n\
6140 ";
6141 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6142 Load Hershey fonts\n\
6143 \n\
6144 DESCRIPTION:\n\
6145 \n\
6146  Loads the Hershey fonts used for text and symbols.\tThis routine may\n\
6147  be called before or after initializing PLplot. If not explicitly\n\
6148  called before PLplot initialization, then by default that\n\
6149  initialization loads Hershey fonts with the extended character set.\n\
6150  This routine only has a practical effect for devices that still use\n\
6151  Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6152  system fonts instead of Hershey fonts).\n\
6153 \n\
6154  Redacted form: plfontld(fnt)\n\
6155 \n\
6156  This function is used in examples 1 and 7.\n\
6157 \n\
6158 \n\
6159 \n\
6160 SYNOPSIS:\n\
6161 \n\
6162 plfontld(fnt)\n\
6163 \n\
6164 ARGUMENTS:\n\
6165 \n\
6166  fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6167  A zero value specifies Hershey fonts with the standard character\n\
6168  set and a non-zero value (the default assumed if plfontld is never\n\
6169  called) specifies Hershey fonts with the extended character set.\n\
6170 ";
6171 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6172 Set any command-line option\n\
6173 \n\
6174 DESCRIPTION:\n\
6175 \n\
6176  Set any command-line option internally from a program before it\n\
6177  invokes plinit. opt is the name of the command-line option and optarg\n\
6178  is the corresponding command-line option argument.\n\
6179 \n\
6180  This function returns 0 on success.\n\
6181 \n\
6182  Redacted form: plsetopt(opt, optarg)\n\
6183 \n\
6184  This function is used in example 14.\n\
6185 \n\
6186 \n\
6187 \n\
6188 SYNOPSIS:\n\
6189 \n\
6190 PLINT plsetopt(opt, optarg)\n\
6191 \n\
6192 ARGUMENTS:\n\
6193 \n\
6194  opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6195  the command-line option.\n\
6196 \n\
6197  optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6198  containing the argument of the command-line option.\n\
6199 ";
6200 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6201 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6202 \n\
6203 DESCRIPTION:\n\
6204 \n\
6205  Plot all or a subset of Shapefile data using lines in world\n\
6206  coordinates. Our 19th standard example demonstrates how to use this\n\
6207  function. This function plots data from a Shapefile using lines as in\n\
6208  plmap, however it also has the option of also only drawing specified\n\
6209  elements from the Shapefile. The vector of indices of the required\n\
6210  elements are passed as a function argument. The Shapefile data should\n\
6211  include a metadata file (extension.dbf) listing all items within the\n\
6212  Shapefile. This file can be opened by most popular spreadsheet\n\
6213  programs and can be used to decide which indices to pass to this\n\
6214  function.\n\
6215 \n\
6216  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6217  plotentries)\n\
6218 \n\
6219  This function is used in example 19.\n\
6220 \n\
6221 \n\
6222 \n\
6223 SYNOPSIS:\n\
6224 \n\
6225 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6226 \n\
6227 ARGUMENTS:\n\
6228 \n\
6229  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6230  transform the coordinates given in the shapefile into a plot\n\
6231  coordinate system. By using this transform, we can change from a\n\
6232  longitude, latitude coordinate to a polar stereographic project,\n\
6233  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6234  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6235  mapform(), x[] and y[] should be replaced by the corresponding\n\
6236  plot coordinates. If no transform is desired, mapform can be\n\
6237  replaced by NULL.\n\
6238 \n\
6239  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6240  the file name of a set of Shapefile files without the file\n\
6241  extension.\n\
6242 \n\
6243  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6244  be in the same units as used by the Shapefile. You could use a\n\
6245  very large negative number to plot everything, but you can improve\n\
6246  performance by limiting the area drawn. The units must match those\n\
6247  of the Shapefile projection, which may be for example longitude or\n\
6248  distance. The value of minx must be less than the value of maxx.\n\
6249 \n\
6250  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6251  use a very large number to plot everything, but you can improve\n\
6252  performance by limiting the area drawn.\n\
6253 \n\
6254  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6255  be in the same units as used by the Shapefile. You could use a\n\
6256  very large negative number to plot everything, but you can improve\n\
6257  performance by limiting the area drawn. The units must match those\n\
6258  of the Shapefile projection, which may be for example latitude or\n\
6259  distance. The value of miny must be less than the value of maxy.\n\
6260 \n\
6261  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6262  use a very large number to plot everything, but you can improve\n\
6263  performance by limiting the area drawn.\n\
6264 \n\
6265  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6266  zero-based indices of the Shapefile elements which will be drawn.\n\
6267  Setting\n\
6268  plotentries to NULL will plot all elements of the Shapefile.\n\
6269 \n\
6270  nplotentries (PLINT, input) : The number of items in\n\
6271  plotentries. Ignored if\n\
6272  plotentries is NULL.\n\
6273 ";
6274 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6275 Used to globally turn color output on/off\n\
6276 \n\
6277 DESCRIPTION:\n\
6278 \n\
6279  Used to globally turn color output on/off for those drivers/devices\n\
6280  that support it.\n\
6281 \n\
6282  Redacted form: plscolor(color)\n\
6283 \n\
6284  This function is used in example 31.\n\
6285 \n\
6286 \n\
6287 \n\
6288 SYNOPSIS:\n\
6289 \n\
6290 plscolor(color)\n\
6291 \n\
6292 ARGUMENTS:\n\
6293 \n\
6294  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6295  turned off. If non-zero, color is turned on.\n\
6296 ";
6297 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6298 Wait for graphics input event and translate to world coordinates.\n\
6299 \n\
6300 DESCRIPTION:\n\
6301 \n\
6302  Wait for graphics input event and translate to world coordinates.\n\
6303  Returns 0 if no translation to world coordinates is possible.\n\
6304 \n\
6305  This function returns 1 on success and 0 if no translation to world\n\
6306  coordinates is possible.\n\
6307 \n\
6308  Redacted form: plGetCursor(gin)\n\
6309 \n\
6310  This function is used in examples 1 and 20.\n\
6311 \n\
6312 \n\
6313 \n\
6314 SYNOPSIS:\n\
6315 \n\
6316 PLINT plGetCursor(gin)\n\
6317 \n\
6318 ARGUMENTS:\n\
6319 \n\
6320  gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6321  which will contain the output. The structure is not allocated by\n\
6322  the routine and must exist before the function is called.\n\
6323 ";
6324 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6325 Get the current device (keyword) name\n\
6326 \n\
6327 DESCRIPTION:\n\
6328 \n\
6329  Get the current device (keyword) name. Note: you must have allocated\n\
6330  space for this (80 characters is safe).\n\
6331 \n\
6332  Redacted form: plgdev(p_dev)\n\
6333 \n\
6334  This function is used in example 14.\n\
6335 \n\
6336 \n\
6337 \n\
6338 SYNOPSIS:\n\
6339 \n\
6340 plgdev(p_dev)\n\
6341 \n\
6342 ARGUMENTS:\n\
6343 \n\
6344  p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6345  (with preallocated length of 80 characters or more) containing the\n\
6346  device (keyword) name.\n\
6347 ";
6348 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6349 Add a point to a strip chart\n\
6350 \n\
6351 DESCRIPTION:\n\
6352 \n\
6353  Add a point to a given pen of a given strip chart. There is no need\n\
6354  for all pens to have the same number of points or to be equally\n\
6355  sampled in the x coordinate. Allocates memory and rescales as\n\
6356  necessary.\n\
6357 \n\
6358  Redacted form: plstripa(id, pen, x, y)\n\
6359 \n\
6360  This function is used in example 17.\n\
6361 \n\
6362 \n\
6363 \n\
6364 SYNOPSIS:\n\
6365 \n\
6366 plstripa(id, pen, x, y)\n\
6367 \n\
6368 ARGUMENTS:\n\
6369 \n\
6370  id (PLINT, input) : Identification number of the strip chart (set\n\
6371  up in plstripc).\n\
6372 \n\
6373  pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6374 \n\
6375  x (PLFLT, input) : X coordinate of point to plot.\n\
6376 \n\
6377  y (PLFLT, input) : Y coordinate of point to plot.\n\
6378 ";
6379 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6380 Create a 4-pen strip chart\n\
6381 \n\
6382 DESCRIPTION:\n\
6383 \n\
6384  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6385 \n\
6386  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6387  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6388  styline, legline, labx, laby, labz)\n\
6389 \t Perl/PDL: plstripc(xmin, xmax, xjump, ymin, ymax, xlpos,\n\
6390  ylpos, y_ascl, acc, colbox, collab, colline, styline, id, xspec,\n\
6391  ypsec, legline, labx, laby, labtop)\n\
6392 \n\
6393 \n\
6394  This function is used in example 17.\n\
6395 \n\
6396 \n\
6397 \n\
6398 SYNOPSIS:\n\
6399 \n\
6400 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6401 \n\
6402 ARGUMENTS:\n\
6403 \n\
6404  id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6405  number of the strip chart to use on plstripa and plstripd.\n\
6406 \n\
6407  xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6408  the x-axis specification as in plbox.\n\
6409 \n\
6410  yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6411  the y-axis specification as in plbox.\n\
6412 \n\
6413  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6414  change as data are added.\n\
6415 \n\
6416  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6417  change as data are added.\n\
6418 \n\
6419  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6420  is multiplied by the factor (1 +\n\
6421  xjump) .\n\
6422 \n\
6423  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6424  change as data are added.\n\
6425 \n\
6426  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6427  change as data are added.\n\
6428 \n\
6429  xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6430 \n\
6431  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6432 \n\
6433  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6434  true, otherwise not.\n\
6435 \n\
6436  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6437  otherwise slide display.\n\
6438 \n\
6439  colbox (PLINT, input) : Plot box color index (cmap0).\n\
6440 \n\
6441  collab (PLINT, input) : Legend color index (cmap0).\n\
6442 \n\
6443  colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6444  indices for the 4 pens.\n\
6445 \n\
6446  styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6447  indices for the 4 pens.\n\
6448 \n\
6449  legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6450  strings containing legends for the 4 pens.\n\
6451 \n\
6452  labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6453  the label for the x axis.\n\
6454 \n\
6455  laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6456  the label for the y axis.\n\
6457 \n\
6458  labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6459  the plot title.\n\
6460 ";
6461 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6462 Deletes and releases memory used by a strip chart\n\
6463 \n\
6464 DESCRIPTION:\n\
6465 \n\
6466  Deletes and releases memory used by a strip chart.\n\
6467 \n\
6468  Redacted form: plstripd(id)\n\
6469 \n\
6470  This function is used in example 17.\n\
6471 \n\
6472 \n\
6473 \n\
6474 SYNOPSIS:\n\
6475 \n\
6476 plstripd(id)\n\
6477 \n\
6478 ARGUMENTS:\n\
6479 \n\
6480  id (PLINT, input) : Identification number of strip chart to delete.\n\
6481 ";
6482 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6483 Specify viewport using coordinates and aspect ratio\n\
6484 \n\
6485 DESCRIPTION:\n\
6486 \n\
6487  Device-independent routine for setting up the viewport. The viewport\n\
6488  is chosen to be the largest with the given aspect ratio that fits\n\
6489  within the specified region (in terms of normalized subpage\n\
6490  coordinates). This routine is functionally equivalent to plvpor when\n\
6491  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6492  routine reserves no extra space at the edges for labels.\n\
6493 \n\
6494  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6495 \n\
6496  This function is used in example 9.\n\
6497 \n\
6498 \n\
6499 \n\
6500 SYNOPSIS:\n\
6501 \n\
6502 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6503 \n\
6504 ARGUMENTS:\n\
6505 \n\
6506  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6507  left-hand edge of the viewport.\n\
6508 \n\
6509  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6510  right-hand edge of the viewport.\n\
6511 \n\
6512  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6513  bottom edge of the viewport.\n\
6514 \n\
6515  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6516  edge of the viewport.\n\
6517 \n\
6518  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6519  axis.\n\
6520 ";
6521 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6522 Assign a function to use for generating custom axis labels\n\
6523 \n\
6524 DESCRIPTION:\n\
6525 \n\
6526  This function allows a user to provide their own function to provide\n\
6527  axis label text. The user function is given the numeric value for a\n\
6528  point on an axis and returns a string label to correspond with that\n\
6529  value. Custom axis labels can be enabled by passing appropriate\n\
6530  arguments to plenv, plbox, plbox3 and similar functions.\n\
6531 \n\
6532  This function is used in example 19.\n\
6533 \n\
6534 \n\
6535 \n\
6536 SYNOPSIS:\n\
6537 \n\
6538 plslabelfunc(label_func, label_data)\n\
6539 \n\
6540 ARGUMENTS:\n\
6541 \n\
6542  label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6543  label function. In order to reset to the default labelling, set\n\
6544  this to NULL. The labelling function parameters are, in order:\n\
6545  axis: This indicates which axis a label is being requested for.\n\
6546  The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6547 \n\
6548  value: This is the value along the axis which is being labelled.\n\
6549 \n\
6550  label_text: The string representation of the label value.\n\
6551 \n\
6552  length: The maximum length in characters allowed for label_text.\n\
6553 \n\
6554 \n\
6555  label_data (PL_GENERIC_POINTER, input) : This parameter may be used\n\
6556  to pass data to the label_func function.\n\
6557 ";
6558 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6559 Set length of major ticks\n\
6560 \n\
6561 DESCRIPTION:\n\
6562 \n\
6563  This sets up the length of the major ticks. The actual length is the\n\
6564  product of the default length and a scaling factor as for character\n\
6565  height.\n\
6566 \n\
6567  Redacted form: plsmaj(def, scale)\n\
6568 \n\
6569  This function is used in example 29.\n\
6570 \n\
6571 \n\
6572 \n\
6573 SYNOPSIS:\n\
6574 \n\
6575 plsmaj(def, scale)\n\
6576 \n\
6577 ARGUMENTS:\n\
6578 \n\
6579  def (PLFLT, input) : The default length of a major tick in\n\
6580  millimeters, should be set to zero if the default length is to\n\
6581  remain unchanged.\n\
6582 \n\
6583  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6584  actual tick length.\n\
6585 ";
6586 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6587 Get the current library version number\n\
6588 \n\
6589 DESCRIPTION:\n\
6590 \n\
6591  Get the current library version number. Note: you must have allocated\n\
6592  space for this (80 characters is safe).\n\
6593 \n\
6594  Redacted form: plgver(p_ver)\n\
6595 \n\
6596  This function is used in example 1.\n\
6597 \n\
6598 \n\
6599 \n\
6600 SYNOPSIS:\n\
6601 \n\
6602 plgver(p_ver)\n\
6603 \n\
6604 ARGUMENTS:\n\
6605 \n\
6606  p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6607  (with preallocated length of 80 characters or more) containing the\n\
6608  PLplot version number.\n\
6609 ";
6610 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6611 Set format of numerical label for contours\n\
6612 \n\
6613 DESCRIPTION:\n\
6614 \n\
6615  Set format of numerical label for contours.\n\
6616 \n\
6617  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6618 \n\
6619  This function is used example 9.\n\
6620 \n\
6621 \n\
6622 \n\
6623 SYNOPSIS:\n\
6624 \n\
6625 pl_setcontlabelformat(lexp, sigdig)\n\
6626 \n\
6627 ARGUMENTS:\n\
6628 \n\
6629  lexp (PLINT, input) : If the contour numerical label is greater\n\
6630  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6631  format is used. Default value of lexp is 4.\n\
6632 \n\
6633  sigdig (PLINT, input) : Number of significant digits. Default\n\
6634  value is 2.\n\
6635 ";
6636 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6637 Parse command-line arguments\n\
6638 \n\
6639 DESCRIPTION:\n\
6640 \n\
6641  Parse command-line arguments.\n\
6642 \n\
6643  plparseopts removes all recognized flags (decreasing argc\n\
6644  accordingly), so that invalid input may be readily detected. It can\n\
6645  also be used to process user command line flags. The user can merge\n\
6646  an option table of type PLOptionTable into the internal option table\n\
6647  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6648  the external table(s) be parsed by calling plClearOpts before\n\
6649  plMergeOpts.\n\
6650 \n\
6651  The default action taken by plparseopts is as follows:\n\
6652  Returns with an error if an unrecognized option or badly formed\n\
6653  option-value pair are encountered.\t\n\
6654  Returns immediately (return code 0) when the first non-option command\n\
6655  line argument is found.\n\
6656  Returns with the return code of the option handler, if one was called.\n\
6657 \n\
6658  Deletes command line arguments from argv list as they are found, and\n\
6659  decrements argc accordingly.\n\
6660  Does not show \"invisible\" options in usage or help messages.\n\
6661  Assumes the program name is contained in argv[0].\n\
6662 \n\
6663  These behaviors may be controlled through the\n\
6664  mode argument.\n\
6665 \n\
6666  Redacted form: General: plparseopts(argv, mode)\n\
6667 \t Perl/PDL: Not available?\n\
6668 \n\
6669 \n\
6670  This function is used in all of the examples.\n\
6671 \n\
6672 \n\
6673 \n\
6674 SYNOPSIS:\n\
6675 \n\
6676 PLINT plparseopts(p_argc, argv, mode)\n\
6677 \n\
6678 ARGUMENTS:\n\
6679 \n\
6680  p_argc (int *, input/output) : Number of arguments.\n\
6681 \n\
6682  argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6683  strings containing *p_argc command-line arguments.\n\
6684 \n\
6685  mode (PLINT, input) : Parsing mode with the following\n\
6686  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6687  and all error messages enabled, including program exit when an\n\
6688  error occurs. Anything on the command line that isn\'t recognized\n\
6689  as a valid option or option argument is flagged as an error.\n\
6690  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6691  of errors.\n\
6692  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6693  arguments.\n\
6694  PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6695  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6696  pointer to the program name.\n\
6697  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6698  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6699  unrecognized arguments.\n\
6700 ";
6701 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
6702 Initialization\n\
6703 \n\
6704 DESCRIPTION:\n\
6705 \n\
6706  Initializing the plotting package.\tThe program prompts for the device\n\
6707  keyword or number of the desired output device. Hitting a RETURN in\n\
6708  response to the prompt is the same as selecting the first device. If\n\
6709  only one device is enabled when PLplot is installed, plstar will issue\n\
6710  no prompt.\tThe output device is divided into nx by ny subpages, each\n\
6711  of which may be used independently. The subroutine pladv is used to\n\
6712  advance from one subpage to the next.\n\
6713 \n\
6714  Redacted form: plstar(nx, ny)\n\
6715 \n\
6716  This function is used in example 1.\n\
6717 \n\
6718 \n\
6719 \n\
6720 SYNOPSIS:\n\
6721 \n\
6722 plstar(nx, ny)\n\
6723 \n\
6724 ARGUMENTS:\n\
6725 \n\
6726  nx (PLINT, input) : Number of subpages to divide output page in the\n\
6727  x direction.\n\
6728 \n\
6729  ny (PLINT, input) : Number of subpages to divide output page in the\n\
6730  y direction.\n\
6731 ";
6732 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
6733 Get FCI (font characterization integer)\n\
6734 \n\
6735 DESCRIPTION:\n\
6736 \n\
6737  Gets information about the current font using the FCI approach. See\n\
6738  the PLplot documentation for more information.\n\
6739 \n\
6740  Redacted form: plgfci(p_fci)\n\
6741 \n\
6742  This function is used in example 23.\n\
6743 \n\
6744 \n\
6745 \n\
6746 SYNOPSIS:\n\
6747 \n\
6748 plgfci(p_fci)\n\
6749 \n\
6750 ARGUMENTS:\n\
6751 \n\
6752  p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
6753  FCI value.\n\
6754 ";
6755 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
6756 Set family file parameters\n\
6757 \n\
6758 DESCRIPTION:\n\
6759 \n\
6760  Sets variables dealing with output file familying.\tDoes nothing if\n\
6761  familying not supported by the driver. This routine, if used, must be\n\
6762  called before initializing PLplot.\tSee the PLplot documentation for\n\
6763  more information.\n\
6764 \n\
6765  Redacted form: plsfam(fam, num, bmax)\n\
6766 \n\
6767  This function is used in examples 14 and 31.\n\
6768 \n\
6769 \n\
6770 \n\
6771 SYNOPSIS:\n\
6772 \n\
6773 plsfam(fam, num, bmax)\n\
6774 \n\
6775 ARGUMENTS:\n\
6776 \n\
6777  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
6778  is enabled.\n\
6779 \n\
6780  num (PLINT, input) : Current family file number.\n\
6781 \n\
6782  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
6783  file.\n\
6784 ";
6785 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
6786 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
6787 \n\
6788 DESCRIPTION:\n\
6789 \n\
6790  This is a variant of plscmap1l that supports alpha channel\n\
6791  transparency. It sets cmap1 colors using a piece-wise linear\n\
6792  relationship between cmap1 intensity index (0.0-1.0) and position in\n\
6793  HLS or RGB color space (see the PLplot documentation) with alpha\n\
6794  transparency value (0.0-1.0). It may be called at any time.\n\
6795 \n\
6796  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
6797  alpha, alt_hue_path)\n\
6798 \n\
6799  This function is used in example 30.\n\
6800 \n\
6801 \n\
6802 \n\
6803 SYNOPSIS:\n\
6804 \n\
6805 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
6806 \n\
6807 ARGUMENTS:\n\
6808 \n\
6809  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
6810 \n\
6811  npts (PLINT, input) : number of control points.\n\
6812 \n\
6813  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
6814  intensity index (0.0-1.0) in ascending order for each control\n\
6815  point.\n\
6816 \n\
6817  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
6818  coordinate (H or R) for each control point.\n\
6819 \n\
6820  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
6821  coordinate (L or G) for each control point.\n\
6822 \n\
6823  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
6824  coordinate (S or B) for each control point.\n\
6825 \n\
6826  alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
6827  transparency value (0.0-1.0) for each control point.\n\
6828 \n\
6829  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
6830  npts - 1 elements) containing the alternative interpolation method\n\
6831  Boolean value for each control point interval. (alt_hue_path[i]\n\
6832  refers to the interpolation interval between the i and i + 1\n\
6833  control points).\n\
6834 ";
6835 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
6836 Set page parameters\n\
6837 \n\
6838 DESCRIPTION:\n\
6839 \n\
6840  Sets the page configuration (optional). If an individual parameter is\n\
6841  zero then that parameter value is not updated. Not all parameters are\n\
6842  recognized by all drivers and the interpretation is device-dependent.\n\
6843  The X-window driver uses the length and offset parameters to determine\n\
6844  the window size and location. The length and offset values are\n\
6845  expressed in units that are specific to the current driver. For\n\
6846  instance: screen drivers will usually interpret them as number of\n\
6847  pixels, whereas printer drivers will usually use mm.\n\
6848 \n\
6849  This routine, if used, must be called before initializing PLplot. It\n\
6850  may be called at later times for interactive drivers to change only\n\
6851  the dpi for subsequent redraws which you can force via a call to\n\
6852  plreplot. If this function is not called then the page size defaults\n\
6853  to landscape A4 for drivers which use real world page sizes and 744\n\
6854  pixels wide by 538 pixels high for raster drivers. The default value\n\
6855  for dx and dy is 90 pixels per inch for raster drivers.\n\
6856 \n\
6857 \n\
6858 \n\
6859  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6860 \n\
6861  This function is used in examples 14 and 31.\n\
6862 \n\
6863 \n\
6864 \n\
6865 SYNOPSIS:\n\
6866 \n\
6867 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
6868 \n\
6869 ARGUMENTS:\n\
6870 \n\
6871  xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
6872  by raster drivers, ignored by drivers which use \"real world\" units\n\
6873  (e.g. mm).\n\
6874 \n\
6875  yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
6876  by raster drivers, ignored by drivers which use \"real world\" units\n\
6877  (e.g. mm).\n\
6878 \n\
6879  xleng (PLINT, input) : Page length, x.\n\
6880 \n\
6881  yleng (PLINT, input) : Page length, y.\n\
6882 \n\
6883  xoff (PLINT, input) : Page offset, x.\n\
6884 \n\
6885  yoff (PLINT, input) : Page offset, y.\n\
6886 ";
6887 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
6888 Set precision in numeric labels\n\
6889 \n\
6890 DESCRIPTION:\n\
6891 \n\
6892  Sets the number of places after the decimal point in numeric labels.\n\
6893 \n\
6894  Redacted form: plprec(setp, prec)\n\
6895 \n\
6896  This function is used in example 29.\n\
6897 \n\
6898 \n\
6899 \n\
6900 SYNOPSIS:\n\
6901 \n\
6902 plprec(setp, prec)\n\
6903 \n\
6904 ARGUMENTS:\n\
6905 \n\
6906  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
6907  automatically determines the number of places to use after the\n\
6908  decimal point in numeric labels (like those used to label axes).\n\
6909  If setp is 1 then prec sets the number of places.\n\
6910 \n\
6911  prec (PLINT, input) : The number of characters to draw after the\n\
6912  decimal point in numeric labels.\n\
6913 ";
6914 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
6915 Copy state parameters from the reference stream to the current stream\n\
6916 \n\
6917 DESCRIPTION:\n\
6918 \n\
6919  Copies state parameters from the reference stream to the current\n\
6920  stream. Tell driver interface to map device coordinates unless flags\n\
6921  == 1.\n\
6922 \n\
6923  This function is used for making save files of selected plots (e.g.\n\
6924  from the TK driver). After initializing, you can get a copy of the\n\
6925  current plot to the specified device by switching to this stream and\n\
6926  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
6927  appropriate. The plot buffer must have previously been enabled (done\n\
6928  automatically by some display drivers, such as X).\n\
6929 \n\
6930  Redacted form: plcpstrm(iplsr, flags)\n\
6931 \n\
6932  This function is used in example 1,20.\n\
6933 \n\
6934 \n\
6935 \n\
6936 SYNOPSIS:\n\
6937 \n\
6938 plcpstrm(iplsr, flags)\n\
6939 \n\
6940 ARGUMENTS:\n\
6941 \n\
6942  iplsr (PLINT, input) : Number of reference stream.\n\
6943 \n\
6944  flags (PLBOOL, input) : If flags is set to true the device\n\
6945  coordinates are not copied from the reference to current stream.\n\
6946 ";
6947 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
6948 Plot a glyph at the specified points\n\
6949 \n\
6950 DESCRIPTION:\n\
6951 \n\
6952  Plot a glyph at the specified points. (This function is largely\n\
6953  superseded by plstring which gives access to many[!] more glyphs.)\n\
6954  code=-1 means try to just draw a point. Right now it\'s just a move\n\
6955  and a draw at the same place. Not ideal, since a sufficiently\n\
6956  intelligent output device may optimize it away, or there may be faster\n\
6957  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6958  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6959  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6960  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6961  code <= 127 the corresponding printable ASCII character is plotted.\n\
6962 \n\
6963  Redacted form: plpoin(x, y, code)\n\
6964 \n\
6965  This function is used in examples 1, 6, 14, and 29.\n\
6966 \n\
6967 \n\
6968 \n\
6969 SYNOPSIS:\n\
6970 \n\
6971 plpoin(n, x, y, code)\n\
6972 \n\
6973 ARGUMENTS:\n\
6974 \n\
6975  n (PLINT, input) : Number of points in the x and y vectors.\n\
6976 \n\
6977  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6978  points.\n\
6979 \n\
6980  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6981  points.\n\
6982 \n\
6983  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6984  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6985  each of the n points.\n\
6986 ";
6987 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
6988 Enter or leave xor mode\n\
6989 \n\
6990 DESCRIPTION:\n\
6991 \n\
6992  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
6993  those drivers (e.g., the xwin driver) that support it. Enables\n\
6994  erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
6995  is not capable of xor operation it returns a status of false.\n\
6996 \n\
6997  Redacted form: plxormod(mode, status)\n\
6998 \n\
6999  This function is used in examples 1 and 20.\n\
7000 \n\
7001 \n\
7002 \n\
7003 SYNOPSIS:\n\
7004 \n\
7005 plxormod(mode, status)\n\
7006 \n\
7007 ARGUMENTS:\n\
7008 \n\
7009  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7010  is false means leave xor mode.\n\
7011 \n\
7012  status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7013  modestatus of true (false) means driver is capable (incapable) of\n\
7014  xor mode.\n\
7015 ";
7016 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7017 Get viewport limits in normalized device coordinates\n\
7018 \n\
7019 DESCRIPTION:\n\
7020 \n\
7021  Get viewport limits in normalized device coordinates.\n\
7022 \n\
7023  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7024 \t Perl/PDL: Not available?\n\
7025 \n\
7026 \n\
7027  This function is used in example 31.\n\
7028 \n\
7029 \n\
7030 \n\
7031 SYNOPSIS:\n\
7032 \n\
7033 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7034 \n\
7035 ARGUMENTS:\n\
7036 \n\
7037  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7038  viewport limit of the normalized device coordinate in x.\n\
7039 \n\
7040  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7041  viewport limit of the normalized device coordinate in x.\n\
7042 \n\
7043  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7044  viewport limit of the normalized device coordinate in y.\n\
7045 \n\
7046  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7047  viewport limit of the normalized device coordinate in y.\n\
7048 ";
7049 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7050 Plot surface mesh\n\
7051 \n\
7052 DESCRIPTION:\n\
7053 \n\
7054  Plots a surface mesh within the environment set up by plw3d. The\n\
7055  surface is defined by the matrix z[\n\
7056  nx][\n\
7057  ny] , the point z[i][j] being the value of the function at (\n\
7058  x[i],\n\
7059  y[j]). Note that the points in vectors x and y do not need to be\n\
7060  equally spaced, but must be stored in ascending order. The parameter\n\
7061  opt controls the way in which the surface is displayed. For further\n\
7062  details see the PLplot documentation.\n\
7063 \n\
7064  Redacted form: plmesh(x, y, z, opt)\n\
7065 \n\
7066  This function is used in example 11.\n\
7067 \n\
7068 \n\
7069 \n\
7070 SYNOPSIS:\n\
7071 \n\
7072 plmesh(x, y, z, nx, ny, opt)\n\
7073 \n\
7074 ARGUMENTS:\n\
7075 \n\
7076  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7077  which the function is evaluated.\n\
7078 \n\
7079  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7080  which the function is evaluated.\n\
7081 \n\
7082  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7083  plot. Should have dimensions of\n\
7084  nx by\n\
7085  ny.\n\
7086 \n\
7087  nx (PLINT, input) : Number of x values at which function has been\n\
7088  evaluated.\n\
7089 \n\
7090  ny (PLINT, input) : Number of y values at which function has been\n\
7091  evaluated.\n\
7092 \n\
7093  opt (PLINT, input) : Determines the way in which the surface is\n\
7094  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7095  function of x for each value of y[j] .\n\
7096  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7097  for each value of x[i] .\n\
7098  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7099  at which function is defined.\n\
7100 ";
7101 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7102 Magnitude colored plot surface mesh with contour\n\
7103 \n\
7104 DESCRIPTION:\n\
7105 \n\
7106  A more powerful form of plmesh: the surface mesh can be colored\n\
7107  accordingly to the current z value being plotted, a contour plot can\n\
7108  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7109  plotted function border and the base XY plane.\n\
7110 \n\
7111  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7112 \n\
7113  This function is used in example 11.\n\
7114 \n\
7115 \n\
7116 \n\
7117 SYNOPSIS:\n\
7118 \n\
7119 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7120 \n\
7121 ARGUMENTS:\n\
7122 \n\
7123  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7124  which the function is evaluated.\n\
7125 \n\
7126  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7127  which the function is evaluated.\n\
7128 \n\
7129  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7130  plot. Should have dimensions of\n\
7131  nx by\n\
7132  ny.\n\
7133 \n\
7134  nx (PLINT, input) : Number of x values at which function is\n\
7135  evaluated.\n\
7136 \n\
7137  ny (PLINT, input) : Number of y values at which function is\n\
7138  evaluated.\n\
7139 \n\
7140  opt (PLINT, input) : Determines the way in which the surface is\n\
7141  represented. To specify more than one option just add the options,\n\
7142  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7143  showing z as a function of x for each value of y[j] .\n\
7144  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7145  for each value of x[i] .\n\
7146  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7147  at which function is defined.\n\
7148  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7149  the z value being plotted. The color is used from the current\n\
7150  cmap1.\n\
7151  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7152  using parameters\n\
7153  nlevel and\n\
7154  clevel.\n\
7155  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7156  the borders of the plotted function.\n\
7157 \n\
7158 \n\
7159  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7160  levels.\n\
7161 \n\
7162  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7163 ";
7164 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7165 End plotting session for current stream\n\
7166 \n\
7167 DESCRIPTION:\n\
7168 \n\
7169  Ends a plotting session for the current output stream only. See\n\
7170  plsstrm for more info.\n\
7171 \n\
7172  Redacted form: plend1()\n\
7173 \n\
7174  This function is used in examples 1 and 20.\n\
7175 \n\
7176 \n\
7177 \n\
7178 SYNOPSIS:\n\
7179 \n\
7180 plend1()\n\
7181 ";
7182 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7183 Get y axis parameters\n\
7184 \n\
7185 DESCRIPTION:\n\
7186 \n\
7187  Identical to plgxax, except that arguments are flags for y axis. See\n\
7188  the description of plgxax for more detail.\n\
7189 \n\
7190  Redacted form: plgyax(p_digmax, p_digits)\n\
7191 \n\
7192  This function is used in example 31.\n\
7193 \n\
7194 \n\
7195 \n\
7196 SYNOPSIS:\n\
7197 \n\
7198 plgyax(p_digmax, p_digits)\n\
7199 \n\
7200 ARGUMENTS:\n\
7201 \n\
7202  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7203  number of digits for the y axis. If nonzero, the printed label\n\
7204  has been switched to a floating-point representation when the\n\
7205  number of digits exceeds this value.\n\
7206 \n\
7207  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7208  number of digits for the numeric labels (y axis) from the last\n\
7209  plot.\n\
7210 ";
7211 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7212 Set plot orientation\n\
7213 \n\
7214 DESCRIPTION:\n\
7215 \n\
7216  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7217  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7218  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7219  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7220  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7221  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7222  not called the default value of rot is 0.\n\
7223 \n\
7224  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7225  probably want to change the aspect ratio to a value suitable for the\n\
7226  plot orientation using a call to plsdidev or the command-line options\n\
7227  -a or -freeaspect.\tFor more documentation of those options see the\n\
7228  PLplot documentation. Such command-line options can be set internally\n\
7229  using plsetopt or set directly using the command line and parsed using\n\
7230  a call to plparseopts.\n\
7231 \n\
7232  Redacted form: plsdiori(rot)\n\
7233 \n\
7234  This function is not used in any examples.\n\
7235 \n\
7236 \n\
7237 \n\
7238 SYNOPSIS:\n\
7239 \n\
7240 plsdiori(rot)\n\
7241 \n\
7242 ARGUMENTS:\n\
7243 \n\
7244  rot (PLFLT, input) : Plot orientation parameter.\n\
7245 ";
7246 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7247 Plot a histogram from unbinned data\n\
7248 \n\
7249 DESCRIPTION:\n\
7250 \n\
7251  Plots a histogram from n data points stored in the data vector. This\n\
7252  routine bins the data into nbin bins equally spaced between datmin and\n\
7253  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7254  opt allows, among other things, the histogram either to be plotted in\n\
7255  an existing window or causes plhist to call plenv with suitable limits\n\
7256  before plotting the histogram.\n\
7257 \n\
7258  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7259 \n\
7260  This function is used in example 5.\n\
7261 \n\
7262 \n\
7263 \n\
7264 SYNOPSIS:\n\
7265 \n\
7266 plhist(n, data, datmin, datmax, nbin, opt)\n\
7267 \n\
7268 ARGUMENTS:\n\
7269 \n\
7270  n (PLINT, input) : Number of data points.\n\
7271 \n\
7272  data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7273  n data points.\n\
7274 \n\
7275  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7276 \n\
7277  datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7278 \n\
7279  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7280  divide the interval xmin to xmax.\n\
7281 \n\
7282  opt (PLINT, input) : Is a combination of several flags:\n\
7283  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7284  the histogram data, the outer bins are expanded to fill up the\n\
7285  entire x-axis, data outside the given extremes are assigned to the\n\
7286  outer bins and bins of zero height are simply drawn.\n\
7287  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7288  to fit the histogram data, without this flag, plenv is called\n\
7289  to set the world coordinates.\n\
7290  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7291  extremes are not taken into account. This option should\n\
7292  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7293  properly present the data.\n\
7294  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7295  size as the ones inside.\n\
7296  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7297  (there is a gap for such bins).\n\
7298 ";
7299 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7300 End plotting session\n\
7301 \n\
7302 DESCRIPTION:\n\
7303 \n\
7304  Ends a plotting session, tidies up all the output files, switches\n\
7305  interactive devices back into text mode and frees up any memory that\n\
7306  was allocated. Must be called before end of program.\n\
7307 \n\
7308  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7309  wait state after a call to plend or other functions which trigger the\n\
7310  end of a plot page. To avoid this, use the plspause function.\n\
7311 \n\
7312  Redacted form: plend()\n\
7313 \n\
7314  This function is used in all of the examples.\n\
7315 \n\
7316 \n\
7317 \n\
7318 SYNOPSIS:\n\
7319 \n\
7320 plend()\n\
7321 ";
7322 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7323 Plot shaded 3-d surface plot\n\
7324 \n\
7325 DESCRIPTION:\n\
7326 \n\
7327  Plots a three-dimensional shaded surface plot within the environment\n\
7328  set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7329  z[\n\
7330  nx][\n\
7331  ny], the point z[i][j] being the value of the function at (\n\
7332  x[i],\n\
7333  y[j]). Note that the points in vectors x and y do not need to be\n\
7334  equally spaced, but must be stored in ascending order. For further\n\
7335  details see the PLplot documentation.\n\
7336 \n\
7337  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7338 \n\
7339  This function is not used in any examples.\n\
7340 \n\
7341 \n\
7342 \n\
7343 SYNOPSIS:\n\
7344 \n\
7345 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7346 \n\
7347 ARGUMENTS:\n\
7348 \n\
7349  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7350  which the function is evaluated.\n\
7351 \n\
7352  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7353  which the function is evaluated.\n\
7354 \n\
7355  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7356  plot. Should have dimensions of\n\
7357  nx by\n\
7358  ny.\n\
7359 \n\
7360  nx (PLINT, input) : Number of x values at which function is\n\
7361  evaluated.\n\
7362 \n\
7363  ny (PLINT, input) : Number of y values at which function is\n\
7364  evaluated.\n\
7365 \n\
7366  opt (PLINT, input) : Determines the way in which the surface is\n\
7367  represented. To specify more than one option just add the options,\n\
7368  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7369  connecting points at which function is defined.\n\
7370  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7371  using parameters\n\
7372  nlevel and\n\
7373  clevel.\n\
7374  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7375  using parameters\n\
7376  nlevel and\n\
7377  clevel.\n\
7378  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7379  the borders of the plotted function.\n\
7380  opt=MAG_COLOR : the surface is colored according to the value\n\
7381  of Z; if MAG_COLOR is not used, then the surface is colored\n\
7382  according to the intensity of the reflected light in the\n\
7383  surface from a light source whose position is set using\n\
7384  pllightsource.\n\
7385 \n\
7386 \n\
7387  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7388  levels.\n\
7389 \n\
7390  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7391 ";
7392 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7393 Set device-compression level\n\
7394 \n\
7395 DESCRIPTION:\n\
7396 \n\
7397  Set device-compression level. Only used for drivers that provide\n\
7398  compression. This function, if used, should be invoked before a call\n\
7399  to plinit.\n\
7400 \n\
7401  Redacted form: plscompression(compression)\n\
7402 \n\
7403  This function is used in example 31.\n\
7404 \n\
7405 \n\
7406 \n\
7407 SYNOPSIS:\n\
7408 \n\
7409 plscompression(compression)\n\
7410 \n\
7411 ARGUMENTS:\n\
7412 \n\
7413  compression (PLINT, input) : The desired compression level. This is\n\
7414  a device-dependent value. Currently only the jpeg and png devices\n\
7415  use these values. For jpeg value is the jpeg quality which should\n\
7416  normally be in the range 0-95. Higher values denote higher quality\n\
7417  and hence larger image sizes. For png values are in the range -1\n\
7418  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7419  A value of -1 denotes the default zlib compression level. Values\n\
7420  in the range 10-99 are divided by 10 and then used as the zlib\n\
7421  compression level. Higher compression levels correspond to greater\n\
7422  compression and small file sizes at the expense of more\n\
7423  computation.\n\
7424 ";
7425 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7426 Get the current device-compression setting\n\
7427 \n\
7428 DESCRIPTION:\n\
7429 \n\
7430  Get the current device-compression setting. This parameter is only\n\
7431  used for drivers that provide compression.\n\
7432 \n\
7433  Redacted form: plgcompression(compression)\n\
7434 \n\
7435  This function is used in example 31.\n\
7436 \n\
7437 \n\
7438 \n\
7439 SYNOPSIS:\n\
7440 \n\
7441 plgcompression(compression)\n\
7442 \n\
7443 ARGUMENTS:\n\
7444 \n\
7445  compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7446  compression setting for the current device.\n\
7447 ";
7448 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7449 Advance the (sub-)page\n\
7450 \n\
7451 DESCRIPTION:\n\
7452 \n\
7453  Advances to the next subpage if sub=0, performing a page advance if\n\
7454  there are no remaining subpages on the current page. If subpages\n\
7455  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7456  PLplot switches to the specified subpage. Note that this allows you\n\
7457  to overwrite a plot on the specified subpage; if this is not what you\n\
7458  intended, use pleop followed by plbop to first advance the page. This\n\
7459  routine is called automatically (with page=0) by plenv, but if plenv\n\
7460  is not used, pladv must be called after initializing PLplot but before\n\
7461  defining the viewport.\n\
7462 \n\
7463  Redacted form: pladv(page)\n\
7464 \n\
7465  This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7466  29, and 31.\n\
7467 \n\
7468 \n\
7469 \n\
7470 SYNOPSIS:\n\
7471 \n\
7472 pladv(page)\n\
7473 \n\
7474 ARGUMENTS:\n\
7475 \n\
7476  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7477  in the top left corner and increasing along the rows) to which to\n\
7478  advance. Set to zero to advance to the next subpage (or to the\n\
7479  next page if subpages are not being used).\n\
7480 ";
7481 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7482 Set parameters of contour labelling other than format of numerical label\n\
7483 \n\
7484 DESCRIPTION:\n\
7485 \n\
7486  Set parameters of contour labelling other than those handled by\n\
7487  pl_setcontlabelformat.\n\
7488 \n\
7489  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7490 \n\
7491  This function is used in example 9.\n\
7492 \n\
7493 \n\
7494 \n\
7495 SYNOPSIS:\n\
7496 \n\
7497 pl_setcontlabelparam(offset, size, spacing, active)\n\
7498 \n\
7499 ARGUMENTS:\n\
7500 \n\
7501  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7502  to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7503 \n\
7504  size (PLFLT, input) : Font height for contour labels (normalized).\n\
7505  Default value is 0.3.\n\
7506 \n\
7507  spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7508  Default value is 0.1.\n\
7509 \n\
7510  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7511  contour labels on. Default is off (0).\n\
7512 ";
7513 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7514 Set family, style and weight of the current font\n\
7515 \n\
7516 DESCRIPTION:\n\
7517 \n\
7518  Sets the current font. See the PLplot documentation for more\n\
7519  information on font selection.\n\
7520 \n\
7521  Redacted form: plsfont(family, style, weight)\n\
7522 \n\
7523  This function is used in example 23.\n\
7524 \n\
7525 \n\
7526 \n\
7527 SYNOPSIS:\n\
7528 \n\
7529 plsfont(family, style, weight)\n\
7530 \n\
7531 ARGUMENTS:\n\
7532 \n\
7533  family (PLINT, input) : Font family to select for the current font.\n\
7534  The available values are given by the PL_FCI_* constants in\n\
7535  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7536  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7537  signifies that the font family should not be altered.\n\
7538 \n\
7539  style (PLINT, input) : Font style to select for the current font.\n\
7540  The available values are given by the PL_FCI_* constants in\n\
7541  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7542  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7543  should not be altered.\n\
7544 \n\
7545  weight (PLINT, input) : Font weight to select for the current font.\n\
7546  The available values are given by the PL_FCI_* constants in\n\
7547  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7548  negative value signifies that the font weight should not be\n\
7549  altered.\n\
7550 ";
7551 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7552 Sets the 3D position of the light source\n\
7553 \n\
7554 DESCRIPTION:\n\
7555 \n\
7556  Sets the 3D position of the light source for use with plsurf3d and\n\
7557  plsurf3dl\n\
7558 \n\
7559  Redacted form: pllightsource(x, y, z)\n\
7560 \n\
7561  This function is used in example 8.\n\
7562 \n\
7563 \n\
7564 \n\
7565 SYNOPSIS:\n\
7566 \n\
7567 pllightsource(x, y, z)\n\
7568 \n\
7569 ARGUMENTS:\n\
7570 \n\
7571  x (PLFLT, input) : X-coordinate of the light source.\n\
7572 \n\
7573  y (PLFLT, input) : Y-coordinate of the light source.\n\
7574 \n\
7575  z (PLFLT, input) : Z-coordinate of the light source.\n\
7576 ";
7577 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7578 Draw a line\n\
7579 \n\
7580 DESCRIPTION:\n\
7581 \n\
7582  Draws line defined by n points in x and y.\n\
7583 \n\
7584  Redacted form: plline(x, y)\n\
7585 \n\
7586  This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7587  25-27, and 29.\n\
7588 \n\
7589 \n\
7590 \n\
7591 SYNOPSIS:\n\
7592 \n\
7593 plline(n, x, y)\n\
7594 \n\
7595 ARGUMENTS:\n\
7596 \n\
7597  n (PLINT, input) : Number of points defining line.\n\
7598 \n\
7599  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7600  points.\n\
7601 \n\
7602  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7603  points.\n\
7604 ";
7605 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7606 Set pen width\n\
7607 \n\
7608 DESCRIPTION:\n\
7609 \n\
7610  Sets the pen width.\n\
7611 \n\
7612  Redacted form: plwidth(width)\n\
7613 \n\
7614  This function is used in examples 1 and 2.\n\
7615 \n\
7616 \n\
7617 \n\
7618 SYNOPSIS:\n\
7619 \n\
7620 plwidth(width)\n\
7621 \n\
7622 ARGUMENTS:\n\
7623 \n\
7624  width (PLFLT, input) : The desired pen width. If width is negative\n\
7625  or the same as the previous value no action is taken. width = 0.\n\
7626  should be interpreted as as the minimum valid pen width for the\n\
7627  device. The interpretation of positive width values is also\n\
7628  device dependent.\n\
7629 ";
7630 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7631 Draw linear gradient inside polygon\n\
7632 \n\
7633 DESCRIPTION:\n\
7634 \n\
7635  Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7636  points (\n\
7637  x[i],\n\
7638  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7639  polygon coordinates and the gradient angle are all expressed in world\n\
7640  coordinates. The angle from the x axis for both the rotated\n\
7641  coordinate system and the gradient vector is specified by angle. The\n\
7642  magnitude of the gradient vector is the difference between the maximum\n\
7643  and minimum values of x for the vertices in the rotated coordinate\n\
7644  system. The origin of the gradient vector can be interpreted as being\n\
7645  anywhere on the line corresponding to the minimum x value for the\n\
7646  vertices in the rotated coordinate system.\tThe distance along the\n\
7647  gradient vector is linearly transformed to the independent variable of\n\
7648  color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7649  1. at the head of the gradient vector. What is drawn is the RGBA\n\
7650  color corresponding to the independent variable of cmap1. For more\n\
7651  information about cmap1 (see the PLplot documentation).\n\
7652 \n\
7653  Redacted form: plgradient(x,y,angle)\n\
7654 \n\
7655  This function is used in examples 25 and 30.\n\
7656 \n\
7657 \n\
7658 \n\
7659 SYNOPSIS:\n\
7660 \n\
7661 plgradient(n, x, y, angle)\n\
7662 \n\
7663 ARGUMENTS:\n\
7664 \n\
7665  n (PLINT, input) : Number of vertices in polygon.\n\
7666 \n\
7667  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7668  vertices.\n\
7669 \n\
7670  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7671  vertices.\n\
7672 \n\
7673  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
7674  axis.\n\
7675 ";
7676 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
7677 Flushes the output stream\n\
7678 \n\
7679 DESCRIPTION:\n\
7680 \n\
7681  Flushes the output stream. Use sparingly, if at all.\n\
7682 \n\
7683  Redacted form: plflush()\n\
7684 \n\
7685  This function is used in examples 1 and 14.\n\
7686 \n\
7687 \n\
7688 \n\
7689 SYNOPSIS:\n\
7690 \n\
7691 plflush()\n\
7692 ";
7693 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
7694 Get plot orientation\n\
7695 \n\
7696 DESCRIPTION:\n\
7697 \n\
7698  Get plot orientation parameter which is multiplied by 90 degrees to\n\
7699  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7700  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7701  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7702  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7703  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7704  not been called the default value pointed to by p_rot will be 0.\n\
7705 \n\
7706  Redacted form: plgdiori(p_rot)\n\
7707 \n\
7708  This function is not used in any examples.\n\
7709 \n\
7710 \n\
7711 \n\
7712 SYNOPSIS:\n\
7713 \n\
7714 plgdiori(p_rot)\n\
7715 \n\
7716 ARGUMENTS:\n\
7717 \n\
7718  p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7719  parameter.\n\
7720 ";
7721 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
7722 Set x axis parameters\n\
7723 \n\
7724 DESCRIPTION:\n\
7725 \n\
7726  Sets values of the digmax and digits flags for the x axis.\tSee the\n\
7727  PLplot documentation for more information.\n\
7728 \n\
7729  Redacted form: plsxax(digmax, digits)\n\
7730 \n\
7731  This function is used in example 31.\n\
7732 \n\
7733 \n\
7734 \n\
7735 SYNOPSIS:\n\
7736 \n\
7737 plsxax(digmax, digits)\n\
7738 \n\
7739 ARGUMENTS:\n\
7740 \n\
7741  digmax (PLINT, input) : Variable to set the maximum number of\n\
7742  digits for the x axis. If nonzero, the printed label will be\n\
7743  switched to a floating-point representation when the number of\n\
7744  digits exceeds digmax.\n\
7745 \n\
7746  digits (PLINT, input) : Field digits value. Currently, changing\n\
7747  its value here has no effect since it is set only by plbox or\n\
7748  plbox3. However, the user may obtain its value after a call to\n\
7749  either of these functions by calling plgxax.\n\
7750 ";
7751 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
7752 Get viewport limits in world coordinates\n\
7753 \n\
7754 DESCRIPTION:\n\
7755 \n\
7756  Get viewport limits in world coordinates.\n\
7757 \n\
7758  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7759 \t Perl/PDL: Not available?\n\
7760 \n\
7761 \n\
7762  This function is used in example 31.\n\
7763 \n\
7764 \n\
7765 \n\
7766 SYNOPSIS:\n\
7767 \n\
7768 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7769 \n\
7770 ARGUMENTS:\n\
7771 \n\
7772  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7773  viewport limit of the world coordinate in x.\n\
7774 \n\
7775  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7776  viewport limit of the world coordinate in x.\n\
7777 \n\
7778  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7779  viewport limit of the world coordinate in y.\n\
7780 \n\
7781  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7782  viewport limit of the world coordinate in y.\n\
7783 ";
7784 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
7785 Shade regions on the basis of value\n\
7786 \n\
7787 DESCRIPTION:\n\
7788 \n\
7789  Shade regions on the basis of value. This is the high-level routine\n\
7790  for making continuous color shaded plots with cmap1 while plshade\n\
7791  should be used to plot individual shaded regions using either cmap0 or\n\
7792  cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
7793  our supported languages.\n\
7794 \n\
7795  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
7796  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
7797  pltr_data)\n\
7798 \t Perl/PDL: plshades(a, xmin, xmax, ymin, ymax, clevel,\n\
7799  fill_width, cont_color, cont_width, fill, rectangular, defined, pltr,\n\
7800  pltr_data)\n\
7801 \n\
7802 \n\
7803  This function is used in examples 16, 21, and 22.\n\
7804 \n\
7805 \n\
7806 \n\
7807 SYNOPSIS:\n\
7808 \n\
7809 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
7810 \n\
7811 ARGUMENTS:\n\
7812 \n\
7813  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7814  plot. Should have dimensions of\n\
7815  nx by\n\
7816  ny.\n\
7817 \n\
7818  nx (PLINT, input) : First dimension of matrix \"a\".\n\
7819 \n\
7820  ny (PLINT, input) : Second dimension of matrix \"a\".\n\
7821 \n\
7822  defined (PLDEFINED_callback, input) : Callback function specifying\n\
7823  the region that should be plotted in the shade plot. This\n\
7824  function accepts x and y coordinates as input arguments and must\n\
7825  return 1 if the point is to be included in the shade plot and 0\n\
7826  otherwise. If you want to plot the entire shade plot (the usual\n\
7827  case), this argument should be set to NULL.\n\
7828 \n\
7829  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
7830  pltr below for how these arguments are used (only for the special case\n\
7831  when the callback function\n\
7832  pltr is not supplied).\n\
7833 \n\
7834  clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
7835  corresponding to the edges of each shaded region that will be\n\
7836  plotted by this function. To work properly the levels should be\n\
7837  monotonic.\n\
7838 \n\
7839  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
7840  of shade edge values in clevel).\n\
7841 \n\
7842  fill_width (PLFLT, input) : Defines the line width used by the fill\n\
7843  pattern.\n\
7844 \n\
7845  cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
7846  contours defining edges of shaded regions. The pen color is only\n\
7847  temporary set for the contour drawing. Set this value to zero or\n\
7848  less if no shade edge contours are wanted.\n\
7849 \n\
7850  cont_width (PLFLT, input) : Defines line width used for contours\n\
7851  defining edges of shaded regions. This value may not be honored\n\
7852  by all drivers. The pen width is only temporary set for the\n\
7853  contour drawing. Set this value to zero or less if no shade edge\n\
7854  contours are wanted.\n\
7855 \n\
7856  fill (PLFILL_callback, input) : Callback routine used to fill the\n\
7857  region. Use plfill for this purpose.\n\
7858 \n\
7859  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
7860  map to rectangles after coordinate transformation with pltrl.\n\
7861  Otherwise, set rectangular to false. If rectangular is set to\n\
7862  true, plshade tries to save time by filling large rectangles.\n\
7863  This optimization fails if the coordinate transformation distorts\n\
7864  the shape of rectangles. For example a plot in polar coordinates\n\
7865  has to have rectangular set to false.\n\
7866 \n\
7867  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
7868  defines the transformation between the zero-based indices of the\n\
7869  matrix a and world coordinates. If\n\
7870  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
7871  indices of a are mapped to the range\n\
7872  xmin through\n\
7873  xmax and the y indices of a are mapped to the range\n\
7874  ymin through\n\
7875  ymax.For the C case, transformation functions are provided in the\n\
7876  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
7877  pltr2 for arbitrary mappings respectively defined by vectors and\n\
7878  matrices. In addition, C callback routines for the transformation\n\
7879  can be supplied by the user such as the mypltr function in\n\
7880  examples/c/x09c.c which provides a general linear transformation\n\
7881  between index coordinates and world coordinates.For languages\n\
7882  other than C you should consult the PLplot documentation for the\n\
7883  details concerning how PLTRANSFORM_callback arguments are\n\
7884  interfaced. However, in general, a particular pattern of\n\
7885  callback-associated arguments such as a tr vector with 6 elements;\n\
7886  xg and yg vectors; or xg and yg matrices are respectively\n\
7887  interfaced to a linear-transformation routine similar to the above\n\
7888  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
7889  sophisticated bindings (see, e.g., the PLplot documentation)\n\
7890  support native language callbacks for handling index to\n\
7891  world-coordinate transformations. Examples of these various\n\
7892  approaches are given in examples/<language>x09*,\n\
7893  examples/<language>x16*, examples/<language>x20*,\n\
7894  examples/<language>x21*, and examples/<language>x22*, for all our\n\
7895  supported languages.\n\
7896 \n\
7897  pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
7898  pass information to pltr0, pltr1, pltr2, or whatever routine that\n\
7899  is externally supplied.\n\
7900 ";
7901 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
7902 Plot color bar for image, shade or gradient plots\n\
7903 \n\
7904 DESCRIPTION:\n\
7905 \n\
7906  Routine for creating a continuous color bar for image, shade, or\n\
7907  gradient plots. (See pllegend for similar functionality for creating\n\
7908  legends with discrete elements). The arguments of plcolorbar provide\n\
7909  control over the location and size of the color bar as well as the\n\
7910  location and characteristics of the elements (most of which are\n\
7911  optional) within that color bar. The resulting color bar is clipped\n\
7912  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
7913  system used for some of the parameters is defined in the documentation\n\
7914  of the position parameter.)\n\
7915 \n\
7916  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
7917  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
7918  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
7919  labels, axis_opts, ticks, sub_ticks, values)\n\
7920 \n\
7921  This function is used in examples 16 and 33.\n\
7922 \n\
7923 \n\
7924 \n\
7925 SYNOPSIS:\n\
7926 \n\
7927 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\
7928 \n\
7929 ARGUMENTS:\n\
7930 \n\
7931  p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
7932  labelled and decorated color bar width in adopted coordinates.\n\
7933 \n\
7934  p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
7935  labelled and decorated color bar height in adopted coordinates.\n\
7936 \n\
7937  opt (PLINT, input) : opt contains bits controlling the overall\n\
7938  color bar. The orientation (direction of the maximum value) of\n\
7939  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
7940  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
7941  specified, the default orientation is toward the top if the\n\
7942  colorbar is placed on the left or right of the viewport or toward\n\
7943  the right if the colorbar is placed on the top or bottom of the\n\
7944  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
7945  (semitransparent) background for the color bar. If the\n\
7946  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
7947  color bar. The type of color bar must be specified with one of\n\
7948  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
7949  more than one of those bits is set only the first one in the above\n\
7950  list is honored. The position of the (optional) label/title can be\n\
7951  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
7952  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
7953  will be drawn. If more than one of this list of bits is specified,\n\
7954  only the first one on the list is honored. End-caps for the color\n\
7955  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
7956  If a particular color bar cap option is not specified then no cap\n\
7957  will be drawn for that end. As a special case for\n\
7958  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
7959  specified. If this option is provided then any tick marks and tick\n\
7960  labels will be placed at the breaks between shaded segments. TODO:\n\
7961  This should be expanded to support custom placement of tick marks\n\
7962  and tick labels at custom value locations for any color bar type.\n\
7963 \n\
7964  position (PLINT, input) : position contains bits which control the\n\
7965  overall position of the color bar and the definition of the\n\
7966  adopted coordinates used for positions just like what is done for\n\
7967  the position argument for pllegend. However, note that the\n\
7968  defaults for the position bits (see below) are different than the\n\
7969  pllegend case. The combination of the PL_POSITION_LEFT,\n\
7970  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
7971  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
7972  the 16 possible standard positions (the 4 corners and centers of\n\
7973  the 4 sides for both the inside and outside cases) of the color\n\
7974  bar relative to the adopted coordinate system. The corner\n\
7975  positions are specified by the appropriate combination of two of\n\
7976  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
7977  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
7978  value of one of those bits. The adopted coordinates are\n\
7979  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
7980  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
7981  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
7982  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
7983  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
7984  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
7985  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
7986  PL_POSITION_VIEWPORT.\n\
7987 \n\
7988  x (PLFLT, input) : X offset of the color bar position in adopted\n\
7989  coordinates from the specified standard position of the color bar.\n\
7990  For positive x, the direction of motion away from the standard\n\
7991  position is inward/outward from the standard corner positions or\n\
7992  standard left or right positions if the\n\
7993  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
7994  For the standard top or bottom positions, the direction of motion\n\
7995  is toward positive X.\n\
7996 \n\
7997  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
7998  coordinates from the specified standard position of the color bar.\n\
7999  For positive y, the direction of motion away from the standard\n\
8000  position is inward/outward from the standard corner positions or\n\
8001  standard top or bottom positions if the\n\
8002  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8003  For the standard left or right positions, the direction of motion\n\
8004  is toward positive Y.\n\
8005 \n\
8006  x_length (PLFLT, input) : Length of the body of the color bar in\n\
8007  the X direction in adopted coordinates.\n\
8008 \n\
8009  y_length (PLFLT, input) : Length of the body of the color bar in\n\
8010  the Y direction in adopted coordinates.\n\
8011 \n\
8012  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8013  color bar (PL_COLORBAR_BACKGROUND).\n\
8014 \n\
8015  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8016  for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8017 \n\
8018  bb_style (PLINT, input) : The pllsty style number for the\n\
8019  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8020 \n\
8021  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8022  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8023 \n\
8024  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8025  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8026 \n\
8027  cont_color (PLINT, input) : The cmap0 contour color for\n\
8028  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8029  it will be interpreted according to the design of plshades.\n\
8030 \n\
8031  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8032  plots. This is passed directly to plshades, so it will be\n\
8033  interpreted according to the design of plshades.\n\
8034 \n\
8035  n_labels (PLINT, input) : Number of labels to place around the\n\
8036  color bar.\n\
8037 \n\
8038  label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8039  n_labels labels.\n\
8040 \n\
8041  labels (PLCHAR_MATRIX, input) : A vector of\n\
8042  n_labels UTF-8 character strings containing the labels for the color\n\
8043  bar. Ignored if no label position is specified with one of the\n\
8044  PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8045  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8046  corresponding label_opts field.\n\
8047 \n\
8048  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8049  value must be greater than 0. It is typically 1 (numerical axis\n\
8050  labels are provided for one of the long edges of the color bar),\n\
8051  but it can be larger if multiple numerical axis labels for the\n\
8052  long edges of the color bar are desired.\n\
8053 \n\
8054  axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8055  n_axes ascii character strings containing options (interpreted as for\n\
8056  plbox) for the color bar\'s axis definitions.\n\
8057 \n\
8058  ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8059  spacing of the major tick marks (interpreted as for plbox) for the\n\
8060  color bar\'s axis definitions.\n\
8061 \n\
8062  sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8063  number of subticks (interpreted as for plbox) for the color bar\'s\n\
8064  axis definitions.\n\
8065 \n\
8066  n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8067  elements in each of the n_axes rows of the values matrix.\n\
8068 \n\
8069  values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8070  values for the data range represented by the color bar. For a row\n\
8071  index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8072  elements in the row is specified by n_values[i_axis]. For\n\
8073  PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8074  is 2, and the corresponding row elements of the values matrix are\n\
8075  the minimum and maximum value represented by the colorbar. For\n\
8076  PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8077  of the values matrix is interpreted the same as the nlevel and\n\
8078  clevel arguments of plshades.\n\
8079 ";
8080 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8081 Get current subpage parameters\n\
8082 \n\
8083 DESCRIPTION:\n\
8084 \n\
8085  Gets the size of the current subpage in millimeters measured from the\n\
8086  bottom left hand corner of the output device page or screen. Can be\n\
8087  used in conjunction with plsvpa for setting the size of a viewport in\n\
8088  absolute coordinates (millimeters).\n\
8089 \n\
8090  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8091 \n\
8092  This function is used in example 23.\n\
8093 \n\
8094 \n\
8095 \n\
8096 SYNOPSIS:\n\
8097 \n\
8098 plgspa(xmin, xmax, ymin, ymax)\n\
8099 \n\
8100 ARGUMENTS:\n\
8101 \n\
8102  xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8103  the left hand edge of the subpage in millimeters.\n\
8104 \n\
8105  xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8106  the right hand edge of the subpage in millimeters.\n\
8107 \n\
8108  ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8109  the bottom edge of the subpage in millimeters.\n\
8110 \n\
8111  ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8112  the top edge of the subpage in millimeters.\n\
8113 ";
8114 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8115 Shade individual region on the basis of value\n\
8116 \n\
8117 DESCRIPTION:\n\
8118 \n\
8119  Shade individual region on the basis of value. Use plshades if you\n\
8120  want to shade a number of contiguous regions using continuous colors.\n\
8121  In particular the edge contours are treated properly in plshades. If\n\
8122  you attempt to do contiguous regions with plshade the contours at the\n\
8123  edge of the shade are partially obliterated by subsequent plots of\n\
8124  contiguous shaded regions.\n\
8125 \n\
8126  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8127  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8128  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8129 \n\
8130 \n\
8131  This function is used in example 15.\n\
8132 \n\
8133 \n\
8134 \n\
8135 SYNOPSIS:\n\
8136 \n\
8137 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\
8138 \n\
8139 ARGUMENTS:\n\
8140 \n\
8141  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8142  plot. Should have dimensions of\n\
8143  nx by\n\
8144  ny.\n\
8145 \n\
8146  nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8147 \n\
8148  ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8149 \n\
8150  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8151  the region that should be plotted in the shade plot. This\n\
8152  function accepts x and y coordinates as input arguments and must\n\
8153  return 1 if the point is to be included in the shade plot and 0\n\
8154  otherwise. If you want to plot the entire shade plot (the usual\n\
8155  case), this argument should be set to NULL.\n\
8156 \n\
8157  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8158  pltr below for how these arguments are used (only for the special case\n\
8159  when the callback function\n\
8160  pltr is not supplied).\n\
8161 \n\
8162  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8163  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8164 \n\
8165  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8166  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8167 \n\
8168  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8169  sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8170  then sh_color is interpreted as a cmap1 argument in the range\n\
8171  (0.0-1.0).\n\
8172 \n\
8173  sh_color (PLFLT, input) : Defines color map index with integer\n\
8174  value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8175 \n\
8176  sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8177 \n\
8178  min_color (PLINT, input) : Defines pen color, width used by the\n\
8179  boundary of shaded region. The min values are used for the\n\
8180  shade_min boundary, and the max values are used on the shade_max\n\
8181  boundary. Set color and width to zero for no plotted boundaries.\n\
8182 \n\
8183  min_width (PLFLT, input) : Defines pen color, width used by the\n\
8184  boundary of shaded region. The min values are used for the\n\
8185  shade_min boundary, and the max values are used on the shade_max\n\
8186  boundary. Set color and width to zero for no plotted boundaries.\n\
8187 \n\
8188  max_color (PLINT, input) : Defines pen color, width used by the\n\
8189  boundary of shaded region. The min values are used for the\n\
8190  shade_min boundary, and the max values are used on the shade_max\n\
8191  boundary. Set color and width to zero for no plotted boundaries.\n\
8192 \n\
8193  max_width (PLFLT, input) : Defines pen color, width used by the\n\
8194  boundary of shaded region. The min values are used for the\n\
8195  shade_min boundary, and the max values are used on the shade_max\n\
8196  boundary. Set color and width to zero for no plotted boundaries.\n\
8197 \n\
8198  fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8199  Use plfill. Future version of PLplot may have other fill\n\
8200  routines.\n\
8201 \n\
8202  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8203  map to rectangles after coordinate transformation with pltrl.\n\
8204  Otherwise, set rectangular to false. If rectangular is set to\n\
8205  true, plshade tries to save time by filling large rectangles.\n\
8206  This optimization fails if the coordinate transformation distorts\n\
8207  the shape of rectangles. For example a plot in polar coordinates\n\
8208  has to have rectangular set to false.\n\
8209 \n\
8210  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8211  defines the transformation between the zero-based indices of the\n\
8212  matrix a and world coordinates. If\n\
8213  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8214  indices of a are mapped to the range\n\
8215  xmin through\n\
8216  xmax and the y indices of a are mapped to the range\n\
8217  ymin through\n\
8218  ymax.For the C case, transformation functions are provided in the\n\
8219  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8220  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8221  matrices. In addition, C callback routines for the transformation\n\
8222  can be supplied by the user such as the mypltr function in\n\
8223  examples/c/x09c.c which provides a general linear transformation\n\
8224  between index coordinates and world coordinates.For languages\n\
8225  other than C you should consult the PLplot documentation for the\n\
8226  details concerning how PLTRANSFORM_callback arguments are\n\
8227  interfaced. However, in general, a particular pattern of\n\
8228  callback-associated arguments such as a tr vector with 6 elements;\n\
8229  xg and yg vectors; or xg and yg matrices are respectively\n\
8230  interfaced to a linear-transformation routine similar to the above\n\
8231  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8232  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8233  support native language callbacks for handling index to\n\
8234  world-coordinate transformations. Examples of these various\n\
8235  approaches are given in examples/<language>x09*,\n\
8236  examples/<language>x16*, examples/<language>x20*,\n\
8237  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8238  supported languages.\n\
8239 \n\
8240  pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
8241  pass information to pltr0, pltr1, pltr2, or whatever routine that\n\
8242  is externally supplied.\n\
8243 ";
8244 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8245 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8246 \n\
8247 DESCRIPTION:\n\
8248 \n\
8249  Calculate world coordinates, wx and wy, and corresponding window index\n\
8250  from relative device coordinates, rx and ry.\n\
8251 \n\
8252  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8253 \t Perl/PDL: Not available?\n\
8254 \n\
8255 \n\
8256  This function is used in example 31.\n\
8257 \n\
8258 \n\
8259 \n\
8260 SYNOPSIS:\n\
8261 \n\
8262 plcalc_world(rx, ry, wx, wy, window)\n\
8263 \n\
8264 ARGUMENTS:\n\
8265 \n\
8266  rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8267  the x coordinate.\n\
8268 \n\
8269  ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8270  the y coordinate.\n\
8271 \n\
8272  wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8273  coordinate corresponding to the relative device coordinates rx and\n\
8274  ry.\n\
8275 \n\
8276  wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8277  coordinate corresponding to the relative device coordinates rx and\n\
8278  ry.\n\
8279 \n\
8280  window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8281  defined window index that corresponds to the input relative device\n\
8282  coordinates (and the returned world coordinates). To give some\n\
8283  background on the window index, for each page the initial window\n\
8284  index is set to zero, and each time plwind is called within the\n\
8285  page, world and device coordinates are stored for the window and\n\
8286  the window index is incremented. Thus, for a simple page layout\n\
8287  with non-overlapping viewports and one window per viewport, window\n\
8288  corresponds to the viewport index (in the order which the\n\
8289  viewport/windows were created) of the only viewport/window\n\
8290  corresponding to rx and ry. However, for more complicated layouts\n\
8291  with potentially overlapping viewports and possibly more than one\n\
8292  window (set of world coordinates) per viewport, window and the\n\
8293  corresponding output world coordinates corresponds to the last\n\
8294  window created that fulfills the criterion that the relative\n\
8295  device coordinates are inside it. Finally, in all cases where the\n\
8296  input relative device coordinates are not inside any\n\
8297  viewport/window, then the returned value of the last defined\n\
8298  window index is set to -1.\n\
8299 ";
8300 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8301 Draw a box with axes, etc, in 3-d\n\
8302 \n\
8303 DESCRIPTION:\n\
8304 \n\
8305  Draws axes, numeric and text labels for a three-dimensional surface\n\
8306  plot. For a more complete description of three-dimensional plotting\n\
8307  see the PLplot documentation.\n\
8308 \n\
8309  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8310  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8311 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
8312  xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
8313 \n\
8314 \n\
8315  This function is used in examples 8, 11, 18, and 21.\n\
8316 \n\
8317 \n\
8318 \n\
8319 SYNOPSIS:\n\
8320 \n\
8321 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8322 \n\
8323 ARGUMENTS:\n\
8324 \n\
8325  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8326  options for the x axis. The string can include any combination of\n\
8327  the following letters (upper or lower case) in any order: b: Draws\n\
8328  axis at base, at height z=\n\
8329  zmin where zmin is defined by call to plw3d. This character must be\n\
8330  specified in order to use any of the other options.\n\
8331  d: Plot labels as date / time. Values are assumed to be\n\
8332  seconds since the epoch (as used by gmtime).\n\
8333  f: Always use fixed point numeric labels.\n\
8334  i: Inverts tick marks, so they are drawn downwards, rather\n\
8335  than upwards.\n\
8336  l: Labels axis logarithmically. This only affects the labels,\n\
8337  not the data, and so it is necessary to compute the logarithms\n\
8338  of data points before passing them to any of the drawing\n\
8339  routines.\n\
8340  n: Writes numeric labels at major tick intervals.\n\
8341  o: Use custom labelling function to generate axis label text.\n\
8342  The custom labelling function can be defined with the\n\
8343  plslabelfunc command.\n\
8344  s: Enables subticks between major ticks, only valid if t is\n\
8345  also specified.\n\
8346  t: Draws major ticks.\n\
8347  u: If this is specified, the text label for the axis is\n\
8348  written under the axis.\n\
8349 \n\
8350 \n\
8351  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8352  the text label for the x axis. It is only drawn if u is in the\n\
8353  xopt string.\n\
8354 \n\
8355  xtick (PLFLT, input) : World coordinate interval between major\n\
8356  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8357  generates a suitable tick interval.\n\
8358 \n\
8359  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8360  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8361  generates a suitable minor tick interval.\n\
8362 \n\
8363  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8364  options for the y axis. The string is interpreted in the same way\n\
8365  as xopt.\n\
8366 \n\
8367  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8368  the text label for the y axis. It is only drawn if u is in the\n\
8369  yopt string.\n\
8370 \n\
8371  ytick (PLFLT, input) : World coordinate interval between major\n\
8372  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8373  generates a suitable tick interval.\n\
8374 \n\
8375  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8376  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8377  generates a suitable minor tick interval.\n\
8378 \n\
8379  zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8380  options for the z axis. The string can include any combination of\n\
8381  the following letters (upper or lower case) in any order: b: Draws\n\
8382  z axis to the left of the surface plot.\n\
8383  c: Draws z axis to the right of the surface plot.\n\
8384  d: Draws grid lines parallel to the x-y plane behind the\n\
8385  figure. These lines are not drawn until after plot3d or\n\
8386  plmesh are called because of the need for hidden line removal.\n\
8387  e: Plot labels as date / time. Values are assumed to be\n\
8388  seconds since the epoch (as used by gmtime). Note this\n\
8389  suboption is interpreted the same as the d suboption for xopt\n\
8390  and yopt, but it has to be identified as e for zopt since d\n\
8391  has already been used for the different purpose above.\n\
8392  f: Always use fixed point numeric labels.\n\
8393  i: Inverts tick marks, so they are drawn away from the center.\n\
8394  l: Labels axis logarithmically. This only affects the labels,\n\
8395  not the data, and so it is necessary to compute the logarithms\n\
8396  of data points before passing them to any of the drawing\n\
8397  routines.\n\
8398  m: Writes numeric labels at major tick intervals on the\n\
8399  right-hand z axis.\n\
8400  n: Writes numeric labels at major tick intervals on the\n\
8401  left-hand z axis.\n\
8402  o: Use custom labelling function to generate axis label text.\n\
8403  The custom labelling function can be defined with the\n\
8404  plslabelfunc command.\n\
8405  s: Enables subticks between major ticks, only valid if t is\n\
8406  also specified.\n\
8407  t: Draws major ticks.\n\
8408  u: If this is specified, the text label is written beside the\n\
8409  left-hand axis.\n\
8410  v: If this is specified, the text label is written beside the\n\
8411  right-hand axis.\n\
8412 \n\
8413 \n\
8414  zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8415  the text label for the z axis. It is only drawn if u or v are in\n\
8416  the zopt string.\n\
8417 \n\
8418  ztick (PLFLT, input) : World coordinate interval between major\n\
8419  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8420  generates a suitable tick interval.\n\
8421 \n\
8422  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8423  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8424  generates a suitable minor tick interval.\n\
8425 ";
8426 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8427 Get character default height and current (scaled) height\n\
8428 \n\
8429 DESCRIPTION:\n\
8430 \n\
8431  Get character default height and current (scaled) height.\n\
8432 \n\
8433  Redacted form: plgchr(p_def, p_ht)\n\
8434 \n\
8435  This function is used in example 23.\n\
8436 \n\
8437 \n\
8438 \n\
8439 SYNOPSIS:\n\
8440 \n\
8441 plgchr(p_def, p_ht)\n\
8442 \n\
8443 ARGUMENTS:\n\
8444 \n\
8445  p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8446  character height (mm).\n\
8447 \n\
8448  p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8449  character height (mm).\n\
8450 ";
8451 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8452 Set the escape character for text strings\n\
8453 \n\
8454 DESCRIPTION:\n\
8455 \n\
8456  Set the escape character for text strings.\tFrom C (in contrast to\n\
8457  Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
8458  selected characters are allowed to prevent the user from shooting\n\
8459  himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
8460  with C\'s use of backslash as a character escape). Here are the\n\
8461  allowed escape characters and their corresponding decimal ASCII\n\
8462  values: !, ASCII 33\n\
8463 \t #, ASCII 35\n\
8464 \t $, ASCII 36\n\
8465 \t %, ASCII 37\n\
8466 \t &, ASCII 38\n\
8467 \t *, ASCII 42\n\
8468 \t @, ASCII 64\n\
8469 \t ^, ASCII 94\n\
8470 \t ~, ASCII 126\n\
8471 \n\
8472 \n\
8473  Redacted form: General: plsesc(esc)\n\
8474 \t Perl/PDL: Not available?\n\
8475 \n\
8476 \n\
8477  This function is used in example 29.\n\
8478 \n\
8479 \n\
8480 \n\
8481 SYNOPSIS:\n\
8482 \n\
8483 plsesc(esc)\n\
8484 \n\
8485 ARGUMENTS:\n\
8486 \n\
8487  esc (char, input) : Escape character.\n\
8488 ";
8489 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8490 Draw a line between two points, accounting for coordinate transforms\n\
8491 \n\
8492 DESCRIPTION:\n\
8493 \n\
8494  Joins the point (\n\
8495  x1,\n\
8496  y1) to (\n\
8497  x2,\n\
8498  y2) . If a global coordinate transform is defined then the line is\n\
8499  broken in to n segments to approximate the path. If no transform is\n\
8500  defined then this simply acts like a call to pljoin.\n\
8501 \n\
8502  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8503 \n\
8504  This function is used in example 22.\n\
8505 \n\
8506 \n\
8507 \n\
8508 SYNOPSIS:\n\
8509 \n\
8510 plpath(n, x1, y1, x2, y2)\n\
8511 \n\
8512 ARGUMENTS:\n\
8513 \n\
8514  n (PLINT, input) : number of points to use to approximate the path.\n\
8515 \n\
8516  x1 (PLFLT, input) : x coordinate of first point.\n\
8517 \n\
8518  y1 (PLFLT, input) : y coordinate of first point.\n\
8519 \n\
8520  x2 (PLFLT, input) : x coordinate of second point.\n\
8521 \n\
8522  y2 (PLFLT, input) : y coordinate of second point.\n\
8523 ";
8524 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8525 Set up standard window and draw box\n\
8526 \n\
8527 DESCRIPTION:\n\
8528 \n\
8529  Sets up plotter environment for simple graphs by calling pladv and\n\
8530  setting up viewport and window to sensible default values. plenv\n\
8531  leaves a standard margin (left-hand margin of eight character heights,\n\
8532  and a margin around the other three sides of five character heights)\n\
8533  around most graphs for axis labels and a title. When these defaults\n\
8534  are not suitable, use the individual routines plvpas, plvpor, or\n\
8535  plvasp for setting up the viewport, plwind for defining the window,\n\
8536  and plbox for drawing the box.\n\
8537 \n\
8538  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8539 \n\
8540  This function is used in example 1,3,9,13,14,19-22,29.\n\
8541 \n\
8542 \n\
8543 \n\
8544 SYNOPSIS:\n\
8545 \n\
8546 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8547 \n\
8548 ARGUMENTS:\n\
8549 \n\
8550  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8551  world coordinates).\n\
8552 \n\
8553  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8554  world coordinates).\n\
8555 \n\
8556  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8557  coordinates).\n\
8558 \n\
8559  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8560  coordinates).\n\
8561 \n\
8562  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8563  scales will not be set, the user must set up the scale before\n\
8564  calling plenv using plsvpa, plvasp or other.\n\
8565  0: the x and y axes are scaled independently to use as much of\n\
8566  the screen as possible.\n\
8567  1: the scales of the x and y axes are made equal.\n\
8568  2: the axis of the x and y axes are made equal, and the plot\n\
8569  box will be square.\n\
8570 \n\
8571 \n\
8572  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8573  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8574  -1: draw box only.\n\
8575  0: draw box, ticks, and numeric tick labels.\n\
8576  1: also draw coordinate axes at x=0 and y=0.\n\
8577  2: also draw a grid at major tick positions in both\n\
8578  coordinates.\n\
8579  3: also draw a grid at minor tick positions in both\n\
8580  coordinates.\n\
8581  10: same as 0 except logarithmic x tick marks. (The x data\n\
8582  have to be converted to logarithms separately.)\n\
8583  11: same as 1 except logarithmic x tick marks. (The x data\n\
8584  have to be converted to logarithms separately.)\n\
8585  12: same as 2 except logarithmic x tick marks. (The x data\n\
8586  have to be converted to logarithms separately.)\n\
8587  13: same as 3 except logarithmic x tick marks. (The x data\n\
8588  have to be converted to logarithms separately.)\n\
8589  20: same as 0 except logarithmic y tick marks. (The y data\n\
8590  have to be converted to logarithms separately.)\n\
8591  21: same as 1 except logarithmic y tick marks. (The y data\n\
8592  have to be converted to logarithms separately.)\n\
8593  22: same as 2 except logarithmic y tick marks. (The y data\n\
8594  have to be converted to logarithms separately.)\n\
8595  23: same as 3 except logarithmic y tick marks. (The y data\n\
8596  have to be converted to logarithms separately.)\n\
8597  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8598  and y data have to be converted to logarithms separately.)\n\
8599  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8600  and y data have to be converted to logarithms separately.)\n\
8601  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8602  and y data have to be converted to logarithms separately.)\n\
8603  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8604  and y data have to be converted to logarithms separately.)\n\
8605  40: same as 0 except date / time x labels.\n\
8606  41: same as 1 except date / time x labels.\n\
8607  42: same as 2 except date / time x labels.\n\
8608  43: same as 3 except date / time x labels.\n\
8609  50: same as 0 except date / time y labels.\n\
8610  51: same as 1 except date / time y labels.\n\
8611  52: same as 2 except date / time y labels.\n\
8612  53: same as 3 except date / time y labels.\n\
8613  60: same as 0 except date / time x and y labels.\n\
8614  61: same as 1 except date / time x and y labels.\n\
8615  62: same as 2 except date / time x and y labels.\n\
8616  63: same as 3 except date / time x and y labels.\n\
8617  70: same as 0 except custom x and y labels.\n\
8618  71: same as 1 except custom x and y labels.\n\
8619  72: same as 2 except custom x and y labels.\n\
8620  73: same as 3 except custom x and y labels.\n\
8621 ";
8622 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8623 Grid data from irregularly sampled data\n\
8624 \n\
8625 DESCRIPTION:\n\
8626 \n\
8627  Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8628  require data organized as a grid, i.e., with x sample point values\n\
8629  independent of y coordinate and vice versa. This function takes\n\
8630  irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8631  vectors; reads the desired grid location from the input vectors\n\
8632  xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8633  grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8634  interpolate the data to the grid is specified with the argument type\n\
8635  which can have one parameter specified in argument data.\n\
8636 \n\
8637  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8638 \t Perl/PDL: Not available?\n\
8639 \t Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8640 \n\
8641 \n\
8642  This function is used in example 21.\n\
8643 \n\
8644 \n\
8645 \n\
8646 SYNOPSIS:\n\
8647 \n\
8648 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8649 \n\
8650 ARGUMENTS:\n\
8651 \n\
8652  x (PLFLT_VECTOR, input) : The input x vector.\n\
8653 \n\
8654  y (PLFLT_VECTOR, input) : The input y vector.\n\
8655 \n\
8656  z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8657  y[i], z[i] represents one data sample coordinate.\n\
8658 \n\
8659  npts (PLINT, input) : The number of data samples in the x, y and z\n\
8660  vectors.\n\
8661 \n\
8662  xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8663  in the x direction. Usually xg has nptsx equally spaced values\n\
8664  from the minimum to the maximum values of the x input vector.\n\
8665 \n\
8666  nptsx (PLINT, input) : The number of points in the xg vector.\n\
8667 \n\
8668  yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8669  in the y direction. Similar to the xg parameter.\n\
8670 \n\
8671  nptsy (PLINT, input) : The number of points in the yg vector.\n\
8672 \n\
8673  zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8674  where data lies in the grid specified by xg and yg. Therefore the\n\
8675  zg matrix must be dimensioned\n\
8676  nptsx by\n\
8677  nptsy.\n\
8678 \n\
8679  type (PLINT, input) : The type of grid interpolation algorithm to\n\
8680  use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
8681  GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
8682  GRID_NNI: Natural Neighbors Interpolation\n\
8683  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
8684  GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
8685  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
8686  Weighted\n\
8687  For details of the algorithms read the source file plgridd.c.\n\
8688 \n\
8689  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
8690  which can be specified through this argument. Currently, for\n\
8691  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
8692  use, the lower the value, the noisier (more local) the\n\
8693  approximation is.\n\
8694  GRID_NNLI, data specifies what a thin triangle is, in the\n\
8695  range [1. .. 2.]. High values enable the usage of very thin\n\
8696  triangles for interpolation, possibly resulting in error in\n\
8697  the approximation.\n\
8698  GRID_NNI, only weights greater than data will be accepted. If\n\
8699  0, all weights will be accepted.\n\
8700 ";
8701 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
8702 Clear current (sub)page\n\
8703 \n\
8704 DESCRIPTION:\n\
8705 \n\
8706  Clears the current page, effectively erasing everything that have been\n\
8707  drawn. This command only works with interactive drivers; if the\n\
8708  driver does not support this, the page is filled with the background\n\
8709  color in use. If the current page is divided into subpages, only the\n\
8710  current subpage is erased.\tThe nth subpage can be selected with\n\
8711  pladv(n).\n\
8712 \n\
8713  Redacted form: General: plclear()\n\
8714 \t Perl/PDL: Not available?\n\
8715 \n\
8716 \n\
8717  This function is not used in any examples.\n\
8718 \n\
8719 \n\
8720 \n\
8721 SYNOPSIS:\n\
8722 \n\
8723 plclear()\n\
8724 ";
8725 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
8726 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8727 \n\
8728 DESCRIPTION:\n\
8729 \n\
8730  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8731  and PLFLT alpha transparency value. This sets the entire color map --\n\
8732  only as many colors as specified will be allocated.\n\
8733 \n\
8734  Redacted form: plscmap0a(r, g, b, alpha)\n\
8735 \n\
8736  This function is used in examples 30.\n\
8737 \n\
8738 \n\
8739 \n\
8740 SYNOPSIS:\n\
8741 \n\
8742 plscmap0a(r, g, b, alpha, ncol0)\n\
8743 \n\
8744 ARGUMENTS:\n\
8745 \n\
8746  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8747  integers (0-255) representing the degree of red in the color.\n\
8748 \n\
8749  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8750  integers (0-255) representing the degree of green in the color.\n\
8751 \n\
8752  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8753  integers (0-255) representing the degree of blue in the color.\n\
8754 \n\
8755  alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8756  representing the alpha transparency of the color.\n\
8757 \n\
8758  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8759  vectors.\n\
8760 ";
8761 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
8762 Set 8-bit RGB values for given cmap0 color index\n\
8763 \n\
8764 DESCRIPTION:\n\
8765 \n\
8766  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
8767  index. Overwrites the previous color value for the given index and,\n\
8768  thus, does not result in any additional allocation of space for\n\
8769  colors.\n\
8770 \n\
8771  Redacted form: plscol0(icol0, r, g, b)\n\
8772 \n\
8773  This function is used in any example 31.\n\
8774 \n\
8775 \n\
8776 \n\
8777 SYNOPSIS:\n\
8778 \n\
8779 plscol0(icol0, r, g, b)\n\
8780 \n\
8781 ARGUMENTS:\n\
8782 \n\
8783  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
8784  number of colors (which is set by default, by plscmap0n, or even\n\
8785  by plscmap0).\n\
8786 \n\
8787  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8788  degree of red in the color.\n\
8789 \n\
8790  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8791  degree of green in the color.\n\
8792 \n\
8793  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8794  degree of blue in the color.\n\
8795 ";
8796 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
8797 Set up transformation from metafile coordinates\n\
8798 \n\
8799 DESCRIPTION:\n\
8800 \n\
8801  Set up transformation from metafile coordinates. The size of the plot\n\
8802  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
8803  general-purpose facility just yet (not sure why the user would need\n\
8804  it, for one).\n\
8805 \n\
8806  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
8807  dimypmm)\n\
8808 \n\
8809  This function is not used in any examples.\n\
8810 \n\
8811 \n\
8812 \n\
8813 SYNOPSIS:\n\
8814 \n\
8815 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
8816 \n\
8817 ARGUMENTS:\n\
8818 \n\
8819  dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
8820 \n\
8821  dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
8822 \n\
8823  dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
8824 \n\
8825  dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
8826 \n\
8827  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
8828 \n\
8829  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
8830 ";
8831 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
8832 Creates a new stream and makes it the default\n\
8833 \n\
8834 DESCRIPTION:\n\
8835 \n\
8836  Creates a new stream and makes it the default. Differs from using\n\
8837  plsstrm, in that a free stream number is found, and returned.\n\
8838  Unfortunately, I have to start at stream 1 and work upward, since\n\
8839  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
8840  that no initial, library-opening call is required.\tSo stream 0 must\n\
8841  be preallocated, and there is no simple way of determining whether it\n\
8842  is already in use or not.\n\
8843 \n\
8844  Redacted form: plmkstrm(p_strm)\n\
8845 \n\
8846  This function is used in examples 1 and 20.\n\
8847 \n\
8848 \n\
8849 \n\
8850 SYNOPSIS:\n\
8851 \n\
8852 plmkstrm(p_strm)\n\
8853 \n\
8854 ARGUMENTS:\n\
8855 \n\
8856  p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
8857  number of the created stream.\n\
8858 ";
8859 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
8860 Get page parameters\n\
8861 \n\
8862 DESCRIPTION:\n\
8863 \n\
8864  Gets the current page configuration. The length and offset values are\n\
8865  expressed in units that are specific to the current driver. For\n\
8866  instance: screen drivers will usually interpret them as number of\n\
8867  pixels, whereas printer drivers will usually use mm.\n\
8868 \n\
8869  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8870 \n\
8871  This function is used in examples 14 and 31.\n\
8872 \n\
8873 \n\
8874 \n\
8875 SYNOPSIS:\n\
8876 \n\
8877 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
8878 \n\
8879 ARGUMENTS:\n\
8880 \n\
8881  p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
8882  pixels/inch (DPI) in x.\n\
8883 \n\
8884  p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
8885  pixels/inch (DPI) in y.\n\
8886 \n\
8887  p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
8888  length.\n\
8889 \n\
8890  p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
8891  length.\n\
8892 \n\
8893  p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
8894  offset.\n\
8895 \n\
8896  p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
8897  offset.\n\
8898 ";
8899 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
8900 Set format for date / time labels\n\
8901 \n\
8902 DESCRIPTION:\n\
8903 \n\
8904  Sets the format for date / time labels. To enable date / time format\n\
8905  labels see the options to plbox, plbox3, and plenv.\n\
8906 \n\
8907  Redacted form: pltimefmt(fmt)\n\
8908 \n\
8909  This function is used in example 29.\n\
8910 \n\
8911 \n\
8912 \n\
8913 SYNOPSIS:\n\
8914 \n\
8915 pltimefmt(fmt)\n\
8916 \n\
8917 ARGUMENTS:\n\
8918 \n\
8919  fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
8920  interpreted similarly to the format specifier of typical system\n\
8921  strftime routines except that PLplot ignores locale and also\n\
8922  supplies some useful extensions in the context of plotting. All\n\
8923  text in the string is printed as-is other than conversion\n\
8924  specifications which take the form of a \'%\' character followed by\n\
8925  further conversion specification character. The conversion\n\
8926  specifications which are similar to those provided by system\n\
8927  strftime routines are the following: %a: The abbreviated (English)\n\
8928  weekday name.\n\
8929  %A: The full (English) weekday name.\n\
8930  %b: The abbreviated (English) month name.\n\
8931  %B: The full (English) month name.\n\
8932  %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
8933  %C: The century number (year/100) as a 2-digit integer.\n\
8934  %d: The day of the month as a decimal number (range 01 to 31).\n\
8935  %D: Equivalent to %m/%d/%y (non-ISO).\n\
8936  %e: Like %d, but a leading zero is replaced by a space.\n\
8937  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
8938  %h: Equivalent to %b.\n\
8939  %H: The hour as a decimal number using a 24-hour clock (range\n\
8940  00 to 23).\n\
8941  %I: The hour as a decimal number using a 12-hour clock (range\n\
8942  01 to 12).\n\
8943  %j: The day of the year as a decimal number (range 001 to\n\
8944  366).\n\
8945  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
8946  23); single digits are preceded by a blank. (See also %H.)\n\
8947  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
8948  12); single digits are preceded by a blank. (See also %I.)\n\
8949  %m: The month as a decimal number (range 01 to 12).\n\
8950  %M: The minute as a decimal number (range 00 to 59).\n\
8951  %n: A newline character.\n\
8952  %p: Either \"AM\" or \"PM\" according to the given time value.\n\
8953  Noon is treated as \"PM\" and midnight as \"AM\".\n\
8954  %r: Equivalent to %I:%M:%S %p.\n\
8955  %R: The time in 24-hour notation (%H:%M). For a version\n\
8956  including the seconds, see %T below.\n\
8957  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
8958  +0000 (UTC).\n\
8959  %S: The second as a decimal number (range 00 to 60). (The\n\
8960  range is up to 60 to allow for occasional leap seconds.)\n\
8961  %t: A tab character.\n\
8962  %T: The time in 24-hour notation (%H:%M:%S).\n\
8963  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
8964  being 1. See also %w.\n\
8965  %U: The week number of the current year as a decimal number,\n\
8966  range 00 to 53, starting with the first Sunday as the first\n\
8967  day of week 01. See also %V and %W.\n\
8968  %v: Equivalent to %e-%b-%Y.\n\
8969  %V: The ISO 8601 week number of the current year as a decimal\n\
8970  number, range 01 to 53, where week 1 is the first week that\n\
8971  has at least 4 days in the new year. See also %U and %W.\n\
8972  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
8973  being 0. See also %u.\n\
8974  %W: The week number of the current year as a decimal number,\n\
8975  range 00 to 53, starting with the first Monday as the first\n\
8976  day of week 01.\n\
8977  %x: Equivalent to %a %b %d %Y.\n\
8978  %X: Equivalent to %T.\n\
8979  %y: The year as a decimal number without a century (range 00\n\
8980  to 99).\n\
8981  %Y: The year as a decimal number including a century.\n\
8982  %z: The UTC time-zone string = \"+0000\".\n\
8983  %Z: The UTC time-zone abbreviation = \"UTC\".\n\
8984  %+: The UTC date and time in default format of the Unix date\n\
8985  command which is equivalent to %a %b %d %T %Z %Y.\n\
8986  %%: A literal \"%\" character.\n\
8987  The conversion specifications which are extensions to those normally\n\
8988  provided by system strftime routines are the following: %(0-9):\n\
8989  The fractional part of the seconds field (including leading\n\
8990  decimal point) to the specified accuracy. Thus %S%3 would give\n\
8991  seconds to millisecond accuracy (00.000).\n\
8992  %.: The fractional part of the seconds field (including\n\
8993  leading decimal point) to the maximum available accuracy. Thus\n\
8994  %S%. would give seconds with fractional part up to 9 decimal\n\
8995  places if available.\n\
8996 ";
8997 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
8998 Specify viewport using aspect ratio only\n\
8999 \n\
9000 DESCRIPTION:\n\
9001 \n\
9002  Selects the largest viewport with the given aspect ratio within the\n\
9003  subpage that leaves a standard margin (left-hand margin of eight\n\
9004  character heights, and a margin around the other three sides of five\n\
9005  character heights).\n\
9006 \n\
9007  Redacted form: plvasp(aspect)\n\
9008 \n\
9009  This function is used in example 13.\n\
9010 \n\
9011 \n\
9012 \n\
9013 SYNOPSIS:\n\
9014 \n\
9015 plvasp(aspect)\n\
9016 \n\
9017 ARGUMENTS:\n\
9018 \n\
9019  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9020  axis of resulting viewport.\n\
9021 ";
9022 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9023 Set output file name\n\
9024 \n\
9025 DESCRIPTION:\n\
9026 \n\
9027  Sets the current output file name, if applicable. If the file name\n\
9028  has not been specified and is required by the driver, the user will be\n\
9029  prompted for it. If using the X-windows output driver, this sets the\n\
9030  display name. This routine, if used, must be called before\n\
9031  initializing PLplot.\n\
9032 \n\
9033  Redacted form: plsfnam(fnam)\n\
9034 \n\
9035  This function is used in examples 1 and 20.\n\
9036 \n\
9037 \n\
9038 \n\
9039 SYNOPSIS:\n\
9040 \n\
9041 plsfnam(fnam)\n\
9042 \n\
9043 ARGUMENTS:\n\
9044 \n\
9045  fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9046  the file name.\n\
9047 ";
9048 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9049 Vector plot\n\
9050 \n\
9051 DESCRIPTION:\n\
9052 \n\
9053  Draws a plot of vector data contained in the matrices (\n\
9054  u[\n\
9055  nx][\n\
9056  ny],\n\
9057  v[\n\
9058  nx][\n\
9059  ny]) . The scaling factor for the vectors is given by scale. A\n\
9060  transformation routine pointed to by pltr with a pointer pltr_data for\n\
9061  additional data required by the transformation routine to map indices\n\
9062  within the matrices to the world coordinates. The style of the vector\n\
9063  arrow may be set using plsvect.\n\
9064 \n\
9065  Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9066  discussion) the pltr, pltr_data callback arguments are sometimes\n\
9067  replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9068  with either one or two dimensions.\n\
9069 \n\
9070  This function is used in example 22.\n\
9071 \n\
9072 \n\
9073 \n\
9074 SYNOPSIS:\n\
9075 \n\
9076 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9077 \n\
9078 ARGUMENTS:\n\
9079 \n\
9080  u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9081  and y components of the vector data to be plotted.\n\
9082 \n\
9083  nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9084 \n\
9085  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9086  the vectors for plotting. If scale = 0 then the scaling factor is\n\
9087  automatically calculated for the data. If scale < 0 then the\n\
9088  scaling factor is automatically calculated for the data and then\n\
9089  multiplied by -\n\
9090  scale. If scale > 0 then the scaling factor is set to scale.\n\
9091 \n\
9092  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9093  defines the transformation between the zero-based indices of the\n\
9094  matrices u and v and world coordinates.For the C case,\n\
9095  transformation functions are provided in the PLplot library: pltr0\n\
9096  for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9097  mappings respectively defined by vectors and matrices. In\n\
9098  addition, C callback routines for the transformation can be\n\
9099  supplied by the user such as the mypltr function in\n\
9100  examples/c/x09c.c which provides a general linear transformation\n\
9101  between index coordinates and world coordinates.For languages\n\
9102  other than C you should consult the PLplot documentation for the\n\
9103  details concerning how PLTRANSFORM_callback arguments are\n\
9104  interfaced. However, in general, a particular pattern of\n\
9105  callback-associated arguments such as a tr vector with 6 elements;\n\
9106  xg and yg vectors; or xg and yg matrices are respectively\n\
9107  interfaced to a linear-transformation routine similar to the above\n\
9108  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9109  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9110  support native language callbacks for handling index to\n\
9111  world-coordinate transformations. Examples of these various\n\
9112  approaches are given in examples/<language>x09*,\n\
9113  examples/<language>x16*, examples/<language>x20*,\n\
9114  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9115  supported languages.\n\
9116 \n\
9117  pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
9118  pass information to pltr0, pltr1, pltr2, or whatever callback\n\
9119  routine that is externally supplied.\n\
9120 ";
9121 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9122 Set parameters that define current plot-space window\n\
9123 \n\
9124 DESCRIPTION:\n\
9125 \n\
9126  Set relative minima and maxima that define the current plot-space\n\
9127  window. If plsdiplt is not called the default values of xmin, ymin,\n\
9128  xmax, and ymax are 0., 0., 1., and 1.\n\
9129 \n\
9130  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9131 \n\
9132  This function is used in example 31.\n\
9133 \n\
9134 \n\
9135 \n\
9136 SYNOPSIS:\n\
9137 \n\
9138 plsdiplt(xmin, ymin, xmax, ymax)\n\
9139 \n\
9140 ARGUMENTS:\n\
9141 \n\
9142  xmin (PLFLT, input) : Relative minimum in x.\n\
9143 \n\
9144  ymin (PLFLT, input) : Relative minimum in y.\n\
9145 \n\
9146  xmax (PLFLT, input) : Relative maximum in x.\n\
9147 \n\
9148  ymax (PLFLT, input) : Relative maximum in y.\n\
9149 ";
9150 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9151 Select line style\n\
9152 \n\
9153 DESCRIPTION:\n\
9154 \n\
9155  This sets the line style according to one of eight predefined patterns\n\
9156  (also see plstyl).\n\
9157 \n\
9158  Redacted form: pllsty(lin)\n\
9159 \n\
9160  This function is used in examples 9, 12, 22, and 25.\n\
9161 \n\
9162 \n\
9163 \n\
9164 SYNOPSIS:\n\
9165 \n\
9166 pllsty(lin)\n\
9167 \n\
9168 ARGUMENTS:\n\
9169 \n\
9170  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9171  a continuous line, line style 2 is a line with short dashes and\n\
9172  gaps, line style 3 is a line with long dashes and gaps, line style\n\
9173  4 has long dashes and short gaps and so on.\n\
9174 ";
9175 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9176 Plot a glyph at the specified points\n\
9177 \n\
9178 DESCRIPTION:\n\
9179 \n\
9180  Plot a glyph at the specified points. (This function is largely\n\
9181  superseded by plstring which gives access to many[!] more glyphs.)\n\
9182 \n\
9183  Redacted form: plsym(x, y, code)\n\
9184 \n\
9185  This function is used in example 7.\n\
9186 \n\
9187 \n\
9188 \n\
9189 SYNOPSIS:\n\
9190 \n\
9191 plsym(n, x, y, code)\n\
9192 \n\
9193 ARGUMENTS:\n\
9194 \n\
9195  n (PLINT, input) : Number of points in the x and y vectors.\n\
9196 \n\
9197  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9198  the points.\n\
9199 \n\
9200  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9201  the points.\n\
9202 \n\
9203  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9204  to be plotted at each of the n points.\n\
9205 ";
9206 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9207 Set the device (keyword) name\n\
9208 \n\
9209 DESCRIPTION:\n\
9210 \n\
9211  Set the device (keyword) name.\n\
9212 \n\
9213  Redacted form: plsdev(devname)\n\
9214 \n\
9215  This function is used in examples 1, 14, and 20.\n\
9216 \n\
9217 \n\
9218 \n\
9219 SYNOPSIS:\n\
9220 \n\
9221 plsdev(devname)\n\
9222 \n\
9223 ARGUMENTS:\n\
9224 \n\
9225  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9226  containing the device name keyword of the required output device.\n\
9227  If\n\
9228  devname is NULL or if the first character of the string is a ``?\'\',\n\
9229  the normal (prompted) start up is used.\n\
9230 ";
9231 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9232 Set the background color by 8-bit RGB value\n\
9233 \n\
9234 DESCRIPTION:\n\
9235 \n\
9236  Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9237  the PLplot documentation).\n\
9238 \n\
9239  Redacted form: plscolbg(r, g, b)\n\
9240 \n\
9241  This function is used in examples 15 and 31.\n\
9242 \n\
9243 \n\
9244 \n\
9245 SYNOPSIS:\n\
9246 \n\
9247 plscolbg(r, g, b)\n\
9248 \n\
9249 ARGUMENTS:\n\
9250 \n\
9251  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9252  degree of red in the color.\n\
9253 \n\
9254  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9255  degree of green in the color.\n\
9256 \n\
9257  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9258  degree of blue in the color.\n\
9259 ";
9260 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9261 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9262 \n\
9263 DESCRIPTION:\n\
9264 \n\
9265  Set relative minima and maxima incrementally (zoom mode) that define\n\
9266  the current plot-space window. This function has the same effect as\n\
9267  plsdiplt if that function has not been previously called. Otherwise,\n\
9268  this function implements zoom mode using the transformation min_used =\n\
9269  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9270  each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
9271  repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9272 \n\
9273  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9274 \n\
9275  This function is used in example 31.\n\
9276 \n\
9277 \n\
9278 \n\
9279 SYNOPSIS:\n\
9280 \n\
9281 plsdiplz(xmin, ymin, xmax, ymax)\n\
9282 \n\
9283 ARGUMENTS:\n\
9284 \n\
9285  xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9286 \n\
9287  ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9288 \n\
9289  xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9290 \n\
9291  ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9292 ";
9293 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9294 Advance to the next family file on the next new page\n\
9295 \n\
9296 DESCRIPTION:\n\
9297 \n\
9298  Advance to the next family file on the next new page.\n\
9299 \n\
9300  Redacted form: plfamadv()\n\
9301 \n\
9302  This function is not used in any examples.\n\
9303 \n\
9304 \n\
9305 \n\
9306 SYNOPSIS:\n\
9307 \n\
9308 plfamadv()\n\
9309 ";
9310 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9311 Set number of colors in cmap0\n\
9312 \n\
9313 DESCRIPTION:\n\
9314 \n\
9315  Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9316  (or reallocate) cmap0, and fill with default values for those colors\n\
9317  not previously allocated. The first 16 default colors are given in\n\
9318  the plcol0 documentation. For larger indices the default color is\n\
9319  red.\n\
9320 \n\
9321  The drivers are not guaranteed to support more than 16 colors.\n\
9322 \n\
9323  Redacted form: plscmap0n(ncol0)\n\
9324 \n\
9325  This function is used in examples 15, 16, and 24.\n\
9326 \n\
9327 \n\
9328 \n\
9329 SYNOPSIS:\n\
9330 \n\
9331 plscmap0n(ncol0)\n\
9332 \n\
9333 ARGUMENTS:\n\
9334 \n\
9335  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9336  the cmap0 palette. If this number is zero or less, then the value\n\
9337  from the previous call to plscmap0n is used and if there is no\n\
9338  previous call, then a default value is used.\n\
9339 ";
9340 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9341 Plot latitude and longitude lines\n\
9342 \n\
9343 DESCRIPTION:\n\
9344 \n\
9345  Displays latitude and longitude on the current plot. The lines are\n\
9346  plotted in the current color and line style.\n\
9347 \n\
9348  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9349  minlat, maxlat)\n\
9350 \n\
9351  This function is used in example 19.\n\
9352 \n\
9353 \n\
9354 \n\
9355 SYNOPSIS:\n\
9356 \n\
9357 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9358 \n\
9359 ARGUMENTS:\n\
9360 \n\
9361  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9362  transform the coordinate longitudes and latitudes to a plot\n\
9363  coordinate system. By using this transform, we can change from a\n\
9364  longitude, latitude coordinate to a polar stereographic project,\n\
9365  for example. Initially, x[0]..[n-1] are the longitudes and\n\
9366  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9367  mapform(), x[] and y[] should be replaced by the corresponding\n\
9368  plot coordinates. If no transform is desired, mapform can be\n\
9369  replaced by NULL.\n\
9370 \n\
9371  dlong (PLFLT, input) : The interval in degrees at which the\n\
9372  longitude lines are to be plotted.\n\
9373 \n\
9374  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9375  lines are to be plotted.\n\
9376 \n\
9377  minlong (PLFLT, input) : The value of the longitude on the left\n\
9378  side of the plot. The value of minlong must be less than the value\n\
9379  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9380  equal to 360.\n\
9381 \n\
9382  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9383  side of the plot.\n\
9384 \n\
9385  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9386  background. One can always use -90.0 as the boundary outside the\n\
9387  plot window will be automatically eliminated. However, the\n\
9388  program will be faster if one can reduce the size of the\n\
9389  background plotted.\n\
9390 \n\
9391  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9392  background. One can always use 90.0 as the boundary outside the\n\
9393  plot window will be automatically eliminated.\n\
9394 ";
9395 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9396 Convert RGB color to HLS\n\
9397 \n\
9398 DESCRIPTION:\n\
9399 \n\
9400  Convert RGB color coordinates to HLS\n\
9401 \n\
9402  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9403 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1?\n\
9404 \n\
9405 \n\
9406  This function is used in example 2.\n\
9407 \n\
9408 \n\
9409 \n\
9410 SYNOPSIS:\n\
9411 \n\
9412 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9413 \n\
9414 ARGUMENTS:\n\
9415 \n\
9416  r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9417 \n\
9418  g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9419 \n\
9420  b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9421 \n\
9422  p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9423  degrees (0.0-360.0) on the color cylinder.\n\
9424 \n\
9425  p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9426  expressed as a fraction (0.0-1.0) of the axis of the color\n\
9427  cylinder.\n\
9428 \n\
9429  p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9430  expressed as a fraction (0.0-1.0) of the radius of the color\n\
9431  cylinder.\n\
9432 ";
9433 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9434 Plot a glyph at the specified 3D points\n\
9435 \n\
9436 DESCRIPTION:\n\
9437 \n\
9438  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9439  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9440  this function similar to what is done for plline3. The glyph is\n\
9441  specified with a PLplot user string. Note that the user string is not\n\
9442  actually limited to one glyph so it is possible (but not normally\n\
9443  useful) to plot more than one glyph at the specified points with this\n\
9444  function. As with plmtex and plptex, the user string can contain FCI\n\
9445  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9446  else PLplot escapes for Hershey or unicode text to determine the\n\
9447  glyph.\n\
9448 \n\
9449  Redacted form: plstring3(x, y, z, string)\n\
9450 \n\
9451  This function is used in example 18.\n\
9452 \n\
9453 \n\
9454 \n\
9455 SYNOPSIS:\n\
9456 \n\
9457 plstring3(n, x, y, z, string)\n\
9458 \n\
9459 ARGUMENTS:\n\
9460 \n\
9461  n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9462 \n\
9463  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9464  the points.\n\
9465 \n\
9466  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9467  the points.\n\
9468 \n\
9469  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9470  the points.\n\
9471 \n\
9472  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9473  the glyph(s) to be plotted at each of the n points. points.\n\
9474 ";
9475 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9476 Switch to text screen\n\
9477 \n\
9478 DESCRIPTION:\n\
9479 \n\
9480  Sets an interactive device to text mode, used in conjunction with\n\
9481  plgra to allow graphics and text to be interspersed. On a device\n\
9482  which supports separate text and graphics windows, this command causes\n\
9483  control to be switched to the text window.\tThis can be useful for\n\
9484  printing diagnostic messages or getting user input, which would\n\
9485  otherwise interfere with the plots. The program must switch back to\n\
9486  the graphics window before issuing plot commands, as the text (or\n\
9487  console) device will probably become quite confused otherwise. If\n\
9488  already in text mode, this command is ignored. It is also ignored on\n\
9489  devices which only support a single window or use a different method\n\
9490  for shifting focus (see also plgra).\n\
9491 \n\
9492  Redacted form: pltext()\n\
9493 \n\
9494  This function is used in example 1.\n\
9495 \n\
9496 \n\
9497 \n\
9498 SYNOPSIS:\n\
9499 \n\
9500 pltext()\n\
9501 ";
9502 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9503 Get parameters that define current plot-space window\n\
9504 \n\
9505 DESCRIPTION:\n\
9506 \n\
9507  Get relative minima and maxima that define current plot-space window.\n\
9508  If plsdiplt has not been called the default values pointed to by\n\
9509  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9510 \n\
9511  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9512 \n\
9513  This function is used in example 31.\n\
9514 \n\
9515 \n\
9516 \n\
9517 SYNOPSIS:\n\
9518 \n\
9519 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9520 \n\
9521 ARGUMENTS:\n\
9522 \n\
9523  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9524  minimum in x.\n\
9525 \n\
9526  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9527  minimum in y.\n\
9528 \n\
9529  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9530  maximum in x.\n\
9531 \n\
9532  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9533  maximum in y.\n\
9534 ";
9535 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9536 Get the (current) run level\n\
9537 \n\
9538 DESCRIPTION:\n\
9539 \n\
9540  Get the (current) run level. Valid settings are: 0, uninitialized\n\
9541 \t 1,\tinitialized\n\
9542 \t 2,\tviewport defined\n\
9543 \t 3,\tworld coordinates defined\n\
9544 \n\
9545 \n\
9546  Redacted form: plglevel(p_level)\n\
9547 \n\
9548  This function is used in example 31.\n\
9549 \n\
9550 \n\
9551 \n\
9552 SYNOPSIS:\n\
9553 \n\
9554 plglevel(p_level)\n\
9555 \n\
9556 ARGUMENTS:\n\
9557 \n\
9558  p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9559  level.\n\
9560 ";
9561 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9562 Plot a histogram from binned data\n\
9563 \n\
9564 DESCRIPTION:\n\
9565 \n\
9566  Plots a histogram consisting of nbin bins.\tThe value associated with\n\
9567  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9568  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9569  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9570  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9571  placed midway between the values in the x vector. Also see plhist for\n\
9572  drawing histograms from unbinned data.\n\
9573 \n\
9574  Redacted form: General: plbin(x, y, opt)\n\
9575 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
9576 \t Python: plbin(nbin, x, y, opt)\n\
9577 \n\
9578 \n\
9579  This function is not used in any examples.\n\
9580 \n\
9581 \n\
9582 \n\
9583 SYNOPSIS:\n\
9584 \n\
9585 plbin(nbin, x, y, opt)\n\
9586 \n\
9587 ARGUMENTS:\n\
9588 \n\
9589  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9590  and y vectors.)\n\
9591 \n\
9592  x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9593  with bins. These must form a strictly increasing sequence.\n\
9594 \n\
9595  y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9596  proportional to the number of points in each bin. This is a PLFLT\n\
9597  (instead of PLINT) vector so as to allow histograms of\n\
9598  probabilities, etc.\n\
9599 \n\
9600  opt (PLINT, input) : Is a combination of several flags:\n\
9601  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9602  outer bins are expanded to fill up the entire x-axis and bins of\n\
9603  zero height are simply drawn.\n\
9604  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9605  between the x values. If the values in x are equally spaced,\n\
9606  the values are the center values of the bins.\n\
9607  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9608  size as the ones inside.\n\
9609  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9610  (there is a gap for such bins).\n\
9611 ";
9612 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9613 Plot a 2D matrix using cmap1\n\
9614 \n\
9615 DESCRIPTION:\n\
9616 \n\
9617  Plot a 2D matrix using cmap1.\n\
9618 \n\
9619  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9620  zmax, valuemin, valuemax, pltr, pltr_data)\n\
9621 \n\
9622 \n\
9623  This function is used in example 20.\n\
9624 \n\
9625 \n\
9626 \n\
9627 SYNOPSIS:\n\
9628 \n\
9629 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9630 \n\
9631 ARGUMENTS:\n\
9632 \n\
9633  idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9634  plot. Should have dimensions of\n\
9635  nx by\n\
9636  ny.\n\
9637 \n\
9638  nx, ny (PLINT, input) : Dimensions of idata\n\
9639 \n\
9640  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9641  pltr below for how these arguments are used (only for the special case\n\
9642  when the callback function\n\
9643  pltr is not supplied).\n\
9644 \n\
9645  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9646  (inclusive) will be plotted.\n\
9647 \n\
9648  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9649  values to use for value to color mappings. A datum equal to or\n\
9650  less than valuemin will be plotted with color 0.0, while a datum\n\
9651  equal to or greater than valuemax will be plotted with color 1.0.\n\
9652  Data between valuemin and valuemax map linearly to colors in the\n\
9653  range (0.0-1.0).\n\
9654 \n\
9655  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9656  defines the transformation between the zero-based indices of the\n\
9657  matrix idata and world coordinates. If\n\
9658  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9659  indices of idata are mapped to the range\n\
9660  xmin through\n\
9661  xmax and the y indices of idata are mapped to the range\n\
9662  ymin through\n\
9663  ymax.For the C case, transformation functions are provided in the\n\
9664  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9665  pltr2 for arbitrary mappings respectively defined by vectors and\n\
9666  matrices. In addition, C callback routines for the transformation\n\
9667  can be supplied by the user such as the mypltr function in\n\
9668  examples/c/x09c.c which provides a general linear transformation\n\
9669  between index coordinates and world coordinates.For languages\n\
9670  other than C you should consult the PLplot documentation for the\n\
9671  details concerning how PLTRANSFORM_callback arguments are\n\
9672  interfaced. However, in general, a particular pattern of\n\
9673  callback-associated arguments such as a tr vector with 6 elements;\n\
9674  xg and yg vectors; or xg and yg matrices are respectively\n\
9675  interfaced to a linear-transformation routine similar to the above\n\
9676  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9677  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9678  support native language callbacks for handling index to\n\
9679  world-coordinate transformations. Examples of these various\n\
9680  approaches are given in examples/<language>x09*,\n\
9681  examples/<language>x16*, examples/<language>x20*,\n\
9682  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9683  supported languages.\n\
9684 \n\
9685  pltr_data (PL_GENERIC_POINTER, input) : Extra parameter to help\n\
9686  pass information to pltr0, pltr1, pltr2, or whatever routine is\n\
9687  externally supplied.\n\
9688 ";
9689 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
9690 Get family, style and weight of the current font\n\
9691 \n\
9692 DESCRIPTION:\n\
9693 \n\
9694  Gets information about current font. See the PLplot documentation for\n\
9695  more information on font selection.\n\
9696 \n\
9697  Redacted form: plgfont(p_family, p_style, p_weight)\n\
9698 \n\
9699  This function is used in example 23.\n\
9700 \n\
9701 \n\
9702 \n\
9703 SYNOPSIS:\n\
9704 \n\
9705 plgfont(p_family, p_style, p_weight)\n\
9706 \n\
9707 ARGUMENTS:\n\
9708 \n\
9709  p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9710  font family. The available values are given by the PL_FCI_*\n\
9711  constants in plplot.h. Current options are PL_FCI_SANS,\n\
9712  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
9713  p_family is NULL then the font family is not returned.\n\
9714 \n\
9715  p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9716  font style. The available values are given by the PL_FCI_*\n\
9717  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
9718  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
9719  style is not returned.\n\
9720 \n\
9721  p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9722  font weight. The available values are given by the PL_FCI_*\n\
9723  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
9724  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
9725  returned.\n\
9726 ";
9727 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
9728 Get z axis parameters\n\
9729 \n\
9730 DESCRIPTION:\n\
9731 \n\
9732  Identical to plgxax, except that arguments are flags for z axis. See\n\
9733  the description of plgxax for more detail.\n\
9734 \n\
9735  Redacted form: plgzax(p_digmax, p_digits)\n\
9736 \n\
9737  This function is used in example 31.\n\
9738 \n\
9739 \n\
9740 \n\
9741 SYNOPSIS:\n\
9742 \n\
9743 plgzax(p_digmax, p_digits)\n\
9744 \n\
9745 ARGUMENTS:\n\
9746 \n\
9747  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
9748  number of digits for the z axis. If nonzero, the printed label\n\
9749  has been switched to a floating-point representation when the\n\
9750  number of digits exceeds this value.\n\
9751 \n\
9752  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
9753  number of digits for the numeric labels (z axis) from the last\n\
9754  plot.\n\
9755 ";
9756 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
9757 Write text inside the viewport of a 3D plot\n\
9758 \n\
9759 DESCRIPTION:\n\
9760 \n\
9761  Writes text at a specified position and inclination and with a\n\
9762  specified shear within the viewport. Text is clipped at the viewport\n\
9763  boundaries. The reference point of a string lies along a line passing\n\
9764  through the string at half the height of a capital letter.\tThe\n\
9765  position of the reference point along this line is determined by just,\n\
9766  and the reference point is placed at world coordinates (\n\
9767  wx,\n\
9768  wy,\n\
9769  wz) within the viewport. The inclination and shear of the string is\n\
9770  specified in terms of differences of world coordinates making it easy\n\
9771  to write text parallel to a line in a graph.\n\
9772 \n\
9773  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
9774 \n\
9775  This function is used in example 28.\n\
9776 \n\
9777 \n\
9778 \n\
9779 SYNOPSIS:\n\
9780 \n\
9781 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
9782 \n\
9783 ARGUMENTS:\n\
9784 \n\
9785  wx (PLFLT, input) : x world coordinate of reference point of\n\
9786  string.\n\
9787 \n\
9788  wy (PLFLT, input) : y world coordinate of reference point of\n\
9789  string.\n\
9790 \n\
9791  wz (PLFLT, input) : z world coordinate of reference point of\n\
9792  string.\n\
9793 \n\
9794  dx (PLFLT, input) : Together with dy and\n\
9795  dz , this specifies the inclination of the string. The baseline of\n\
9796  the string is parallel to a line joining (\n\
9797  x,\n\
9798  y,\n\
9799  z) to (\n\
9800  x+\n\
9801  dx,\n\
9802  y+\n\
9803  dy,\n\
9804  z+\n\
9805  dz) .\n\
9806 \n\
9807  dy (PLFLT, input) : Together with dx and\n\
9808  dz, this specifies the inclination of the string.\n\
9809 \n\
9810  dz (PLFLT, input) : Together with dx and\n\
9811  dy, this specifies the inclination of the string.\n\
9812 \n\
9813  sx (PLFLT, input) : Together with sy and\n\
9814  sz , this specifies the shear of the string. The string is sheared so\n\
9815  that the characters are vertically parallel to a line joining (\n\
9816  x,\n\
9817  y,\n\
9818  z) to (\n\
9819  x+\n\
9820  sx,\n\
9821  y+\n\
9822  sy,\n\
9823  z+\n\
9824  sz) . If sx =\n\
9825  sy =\n\
9826  sz = 0.) then the text is not sheared.\n\
9827 \n\
9828  sy (PLFLT, input) : Together with sx and\n\
9829  sz, this specifies shear of the string.\n\
9830 \n\
9831  sz (PLFLT, input) : Together with sx and\n\
9832  sy, this specifies shear of the string.\n\
9833 \n\
9834  just (PLFLT, input) : Specifies the position of the string relative\n\
9835  to its reference point. If just=0. , the reference point is at\n\
9836  the left and if just=1. , it is at the right of the string. Other\n\
9837  values of just give intermediate justifications.\n\
9838 \n\
9839  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
9840  written out.\n\
9841 ";
9842 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
9843 Draw a box with axes, etc. with arbitrary origin\n\
9844 \n\
9845 DESCRIPTION:\n\
9846 \n\
9847  Draws a box around the currently defined viewport with arbitrary\n\
9848  world-coordinate origin specified by x0 and y0 and labels it with\n\
9849  world coordinate values appropriate to the window.\tThus plaxes should\n\
9850  only be called after defining both viewport and window. The ascii\n\
9851  character strings xopt and yopt specify how the box should be drawn as\n\
9852  described below. If ticks and/or subticks are to be drawn for a\n\
9853  particular axis, the tick intervals and number of subintervals may be\n\
9854  specified explicitly, or they may be defaulted by setting the\n\
9855  appropriate arguments to zero.\n\
9856 \n\
9857  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
9858  ytick, nysub)\n\
9859 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
9860  yopt)\n\
9861 \n\
9862 \n\
9863  This function is not used in any examples.\n\
9864 \n\
9865 \n\
9866 \n\
9867 SYNOPSIS:\n\
9868 \n\
9869 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
9870 \n\
9871 ARGUMENTS:\n\
9872 \n\
9873  x0 (PLFLT, input) : World X coordinate of origin.\n\
9874 \n\
9875  y0 (PLFLT, input) : World Y coordinate of origin.\n\
9876 \n\
9877  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
9878  options for the x axis. The string can include any combination of\n\
9879  the following letters (upper or lower case) in any order: a: Draws\n\
9880  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
9881  (x=0).\n\
9882  b: Draws bottom (X) or left (Y) edge of frame.\n\
9883  c: Draws top (X) or right (Y) edge of frame.\n\
9884  d: Plot labels as date / time. Values are assumed to be\n\
9885  seconds since the epoch (as used by gmtime).\n\
9886  f: Always use fixed point numeric labels.\n\
9887  g: Draws a grid at the major tick interval.\n\
9888  h: Draws a grid at the minor tick interval.\n\
9889  i: Inverts tick marks, so they are drawn outwards, rather than\n\
9890  inwards.\n\
9891  l: Labels axis logarithmically. This only affects the labels,\n\
9892  not the data, and so it is necessary to compute the logarithms\n\
9893  of data points before passing them to any of the drawing\n\
9894  routines.\n\
9895  m: Writes numeric labels at major tick intervals in the\n\
9896  unconventional location (above box for X, right of box for Y).\n\
9897  n: Writes numeric labels at major tick intervals in the\n\
9898  conventional location (below box for X, left of box for Y).\n\
9899  o: Use custom labelling function to generate axis label text.\n\
9900  The custom labelling function can be defined with the\n\
9901  plslabelfunc command.\n\
9902  s: Enables subticks between major ticks, only valid if t is\n\
9903  also specified.\n\
9904  t: Draws major ticks.\n\
9905  u: Exactly like \"b\" except don\'t draw edge line.\n\
9906  w: Exactly like \"c\" except don\'t draw edge line.\n\
9907  x: Exactly like \"t\" (including the side effect of the\n\
9908  numerical labels for the major ticks) except exclude drawing\n\
9909  the major and minor tick marks.\n\
9910 \n\
9911 \n\
9912  xtick (PLFLT, input) : World coordinate interval between major\n\
9913  ticks on the x axis. If it is set to zero, PLplot automatically\n\
9914  generates a suitable tick interval.\n\
9915 \n\
9916  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
9917  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9918  generates a suitable minor tick interval.\n\
9919 \n\
9920  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
9921  options for the y axis. The string can include any combination of\n\
9922  the letters defined above for xopt, and in addition may contain:\n\
9923  v: Write numeric labels for the y axis parallel to the base of the\n\
9924  graph, rather than parallel to the axis.\n\
9925 \n\
9926 \n\
9927  ytick (PLFLT, input) : World coordinate interval between major\n\
9928  ticks on the y axis. If it is set to zero, PLplot automatically\n\
9929  generates a suitable tick interval.\n\
9930 \n\
9931  nysub (PLINT, input) : Number of subintervals between major y axis\n\
9932  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
9933  generates a suitable minor tick interval.\n\
9934 ";
9935 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
9936 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
9937 \n\
9938 DESCRIPTION:\n\
9939 \n\
9940  Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
9941 \n\
9942  Redacted form: plgcolbg(r, g, b)\n\
9943 \n\
9944  This function is used in example 31.\n\
9945 \n\
9946 \n\
9947 \n\
9948 SYNOPSIS:\n\
9949 \n\
9950 plgcolbg(r, g, b)\n\
9951 \n\
9952 ARGUMENTS:\n\
9953 \n\
9954  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
9955  in the range from 0 to 255.\n\
9956 \n\
9957  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
9958  in the range from 0 to 255.\n\
9959 \n\
9960  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
9961  in the range from 0 to 255.\n\
9962 ";
9963 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
9964 Plot a glyph at the specified 3D points\n\
9965 \n\
9966 DESCRIPTION:\n\
9967 \n\
9968  Plot a glyph at the specified 3D points. (This function is largely\n\
9969  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
9970  Set up the call to this function similar to what is done for plline3.\n\
9971  code=-1 means try to just draw a point. Right now it\'s just a move\n\
9972  and a draw at the same place. Not ideal, since a sufficiently\n\
9973  intelligent output device may optimize it away, or there may be faster\n\
9974  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
9975  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
9976  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
9977  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
9978  code <= 127 the corresponding printable ASCII character is plotted.\n\
9979 \n\
9980  Redacted form: plpoin3(x, y, z, code)\n\
9981 \n\
9982  This function is not used in any example.\n\
9983 \n\
9984 \n\
9985 \n\
9986 SYNOPSIS:\n\
9987 \n\
9988 plpoin3(n, x, y, z, code)\n\
9989 \n\
9990 ARGUMENTS:\n\
9991 \n\
9992  n (PLINT, input) : Number of points in the x and y vectors.\n\
9993 \n\
9994  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9995  points.\n\
9996 \n\
9997  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9998  points.\n\
9999 \n\
10000  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10001  points.\n\
10002 \n\
10003  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10004  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10005  each of the n points.\n\
10006 ";
10007 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10008 Draw a polygon in 3 space\n\
10009 \n\
10010 DESCRIPTION:\n\
10011 \n\
10012  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10013  like plline3, but differs from that function in that plpoly3 attempts\n\
10014  to determine if the polygon is viewable depending on the order of the\n\
10015  points within the vector and the value of ifcc. If the back of\n\
10016  polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
10017  you want, then use plline3 instead.\n\
10018 \n\
10019  The points are assumed to be in a plane, and the directionality of the\n\
10020  plane is determined from the first three points. Additional points do\n\
10021  not have to lie on the plane defined by the first three, but if they\n\
10022  do not, then the determination of visibility obviously can\'t be 100%\n\
10023  accurate... So if you\'re 3 space polygons are too far from planar,\n\
10024  consider breaking them into smaller polygons. 3 points define a plane\n\
10025  :-).\n\
10026 \n\
10027  Bugs: If one of the first two segments is of zero length, or if they\n\
10028  are co-linear, the calculation of visibility has a 50/50 chance of\n\
10029  being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
10030  of this problem. (Search for 20.1).\n\
10031 \n\
10032  Redacted form: plpoly3(x, y, z, code)\n\
10033 \n\
10034  This function is used in example 18.\n\
10035 \n\
10036 \n\
10037 \n\
10038 SYNOPSIS:\n\
10039 \n\
10040 plpoly3(n, x, y, z, draw, ifcc)\n\
10041 \n\
10042 ARGUMENTS:\n\
10043 \n\
10044  n (PLINT, input) : Number of points defining line.\n\
10045 \n\
10046  x (PLFLT_VECTOR, input) : A vector containing\n\
10047  n x coordinates of points.\n\
10048 \n\
10049  y (PLFLT_VECTOR, input) : A vector containing\n\
10050  n y coordinates of points.\n\
10051 \n\
10052  z (PLFLT_VECTOR, input) : A vector containing\n\
10053  n z coordinates of points.\n\
10054 \n\
10055  draw (PLBOOL_VECTOR, input) : A vector containing\n\
10056  n-1 Boolean values which control drawing the segments of the polygon.\n\
10057  If draw[i] is true, then the polygon segment from index [i] to\n\
10058  [i+1] is drawn, otherwise, not.\n\
10059 \n\
10060  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10061  polygon is determined by assuming the points are laid out in a\n\
10062  counter-clockwise order. Otherwise, the directionality of the\n\
10063  polygon is determined by assuming the points are laid out in a\n\
10064  clockwise order.\n\
10065 ";
10066 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10067 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10068 \n\
10069 DESCRIPTION:\n\
10070 \n\
10071  Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10072  PLFLT alpha transparency value (see the PLplot documentation).\n\
10073 \n\
10074  This function is used in example 31.\n\
10075 \n\
10076 \n\
10077 \n\
10078 SYNOPSIS:\n\
10079 \n\
10080 plscolbga(r, g, b, alpha)\n\
10081 \n\
10082 ARGUMENTS:\n\
10083 \n\
10084  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10085  degree of red in the color.\n\
10086 \n\
10087  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10088  degree of green in the color.\n\
10089 \n\
10090  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10091  degree of blue in the color.\n\
10092 \n\
10093  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10094  (0.0-1.0).\n\
10095 ";
10096 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10097 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10098 \n\
10099 DESCRIPTION:\n\
10100 \n\
10101  Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10102  alpha transparency value.\n\
10103 \n\
10104  This function is used in example 31.\n\
10105 \n\
10106 \n\
10107 \n\
10108 SYNOPSIS:\n\
10109 \n\
10110 plgcolbga(r, g, b, alpha)\n\
10111 \n\
10112 ARGUMENTS:\n\
10113 \n\
10114  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10115  in the range from 0 to 255.\n\
10116 \n\
10117  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10118  in the range from 0 to 255.\n\
10119 \n\
10120  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10121  in the range from 0 to 255.\n\
10122 \n\
10123  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10124  transparency in the range (0.0-1.0).\n\
10125 ";
10126 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10127 Draw error bars in x direction\n\
10128 \n\
10129 DESCRIPTION:\n\
10130 \n\
10131  Draws a set of n error bars in x direction, the i\'th error bar\n\
10132  extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10133  of the error bars are of length equal to the minor tick length\n\
10134  (settable using plsmin).\n\
10135 \n\
10136  Redacted form: General: plerrx(xmin, ymax, y)\n\
10137 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
10138 \n\
10139 \n\
10140  This function is used in example 29.\n\
10141 \n\
10142 \n\
10143 \n\
10144 SYNOPSIS:\n\
10145 \n\
10146 plerrx(n, xmin, xmax, y)\n\
10147 \n\
10148 ARGUMENTS:\n\
10149 \n\
10150  n (PLINT, input) : Number of error bars to draw.\n\
10151 \n\
10152  xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10153  of the left-hand endpoints of the error bars.\n\
10154 \n\
10155  xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10156  of the right-hand endpoints of the error bars.\n\
10157 \n\
10158  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10159  the error bars.\n\
10160 ";
10161 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10162 Eject current page\n\
10163 \n\
10164 DESCRIPTION:\n\
10165 \n\
10166  Clears the graphics screen of an interactive device, or ejects a page\n\
10167  on a plotter. See plbop for more information.\n\
10168 \n\
10169  Redacted form: pleop()\n\
10170 \n\
10171  This function is used in example 2,14.\n\
10172 \n\
10173 \n\
10174 \n\
10175 SYNOPSIS:\n\
10176 \n\
10177 pleop()\n\
10178 ";
10179 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10180 Convert HLS color to RGB\n\
10181 \n\
10182 DESCRIPTION:\n\
10183 \n\
10184  Convert HLS color coordinates to RGB.\n\
10185 \n\
10186  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10187 \t Perl/PDL: Not available? Implemented as plhls?\n\
10188 \n\
10189 \n\
10190  This function is used in example 2.\n\
10191 \n\
10192 \n\
10193 \n\
10194 SYNOPSIS:\n\
10195 \n\
10196 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10197 \n\
10198 ARGUMENTS:\n\
10199 \n\
10200  h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10201  cylinder.\n\
10202 \n\
10203  l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10204  the axis of the color cylinder.\n\
10205 \n\
10206  s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10207  the radius of the color cylinder.\n\
10208 \n\
10209  p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10210  (0.0-1.0) of the color.\n\
10211 \n\
10212  p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10213  intensity (0.0-1.0) of the color.\n\
10214 \n\
10215  p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10216  intensity (0.0-1.0) of the color.\n\
10217 ";
10218 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10219 Plot all or a subset of Shapefile data, filling the polygons\n\
10220 \n\
10221 DESCRIPTION:\n\
10222 \n\
10223  As per plmapline, however the items are filled in the same way as\n\
10224  plfill.\n\
10225 \n\
10226  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10227  plotentries)\n\
10228 \n\
10229  This function is used in example 19.\n\
10230 \n\
10231 \n\
10232 \n\
10233 SYNOPSIS:\n\
10234 \n\
10235 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10236 \n\
10237 ARGUMENTS:\n\
10238 \n\
10239  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10240  transform the coordinates given in the shapefile into a plot\n\
10241  coordinate system. By using this transform, we can change from a\n\
10242  longitude, latitude coordinate to a polar stereographic project,\n\
10243  for example. Initially, x[0]..[n-1] are the longitudes and\n\
10244  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10245  mapform(), x[] and y[] should be replaced by the corresponding\n\
10246  plot coordinates. If no transform is desired, mapform can be\n\
10247  replaced by NULL.\n\
10248 \n\
10249  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10250  the file name of a set of Shapefile files without the file\n\
10251  extension.\n\
10252 \n\
10253  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10254  be in the same units as used by the Shapefile. You could use a\n\
10255  very large negative number to plot everything, but you can improve\n\
10256  performance by limiting the area drawn. The units must match those\n\
10257  of the Shapefile projection, which may be for example longitude or\n\
10258  distance. The value of minx must be less than the value of maxx.\n\
10259 \n\
10260  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10261  use a very large number to plot everything, but you can improve\n\
10262  performance by limiting the area drawn.\n\
10263 \n\
10264  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10265  be in the same units as used by the Shapefile. You could use a\n\
10266  very large negative number to plot everything, but you can improve\n\
10267  performance by limiting the area drawn. The units must match those\n\
10268  of the Shapefile projection, which may be for example latitude or\n\
10269  distance. The value of miny must be less than the value of maxy.\n\
10270 \n\
10271  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10272  use a very large number to plot everything, but you can improve\n\
10273  performance by limiting the area drawn.\n\
10274 \n\
10275  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10276  zero-based indices of the Shapefile elements which will be drawn.\n\
10277  Setting\n\
10278  plotentries to NULL will plot all elements of the Shapefile.\n\
10279 \n\
10280  nplotentries (PLINT, input) : The number of items in\n\
10281  plotentries. Ignored if\n\
10282  plotentries is NULL.\n\
10283 ";
10284 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10285 Draw error bars in the y direction\n\
10286 \n\
10287 DESCRIPTION:\n\
10288 \n\
10289  Draws a set of n error bars in the y direction, the i\'th error bar\n\
10290  extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10291  of the error bars are of length equal to the minor tick length\n\
10292  (settable using plsmin).\n\
10293 \n\
10294  Redacted form: General: plerry(x, ymin, ymax)\n\
10295 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
10296 \n\
10297 \n\
10298  This function is used in example 29.\n\
10299 \n\
10300 \n\
10301 \n\
10302 SYNOPSIS:\n\
10303 \n\
10304 plerry(n, x, ymin, ymax)\n\
10305 \n\
10306 ARGUMENTS:\n\
10307 \n\
10308  n (PLINT, input) : Number of error bars to draw.\n\
10309 \n\
10310  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10311  the error bars.\n\
10312 \n\
10313  ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10314  of the lower endpoints of the error bars.\n\
10315 \n\
10316  ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10317  of the upper endpoints of the error bars.\n\
10318 ";
10319 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10320 Set FCI (font characterization integer)\n\
10321 \n\
10322 DESCRIPTION:\n\
10323 \n\
10324  Sets font characteristics to be used at the start of the next string\n\
10325  using the FCI approach. See the PLplot documentation for more\n\
10326  information. Note, plsfont (which calls plsfci internally) provides a\n\
10327  more user-friendly API for setting the font characterisitics.\n\
10328 \n\
10329  Redacted form: General: plsfci(fci)\n\
10330 \t Perl/PDL: Not available?\n\
10331 \n\
10332 \n\
10333  This function is used in example 23.\n\
10334 \n\
10335 \n\
10336 \n\
10337 SYNOPSIS:\n\
10338 \n\
10339 plsfci(fci)\n\
10340 \n\
10341 ARGUMENTS:\n\
10342 \n\
10343  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10344  of FCI.\n\
10345 ";
10346 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10347 Select area fill pattern\n\
10348 \n\
10349 DESCRIPTION:\n\
10350 \n\
10351  If\n\
10352  patt is zero or less use either a hardware solid fill if the drivers\n\
10353  have that capability (virtually all do) or fall back to a software\n\
10354  emulation of a solid fill using the eighth area line fill pattern.\tIf\n\
10355  0 <\n\
10356  patt <= 8, then select one of eight predefined area line fill patterns\n\
10357  to use (see plpat if you desire other patterns).\n\
10358 \n\
10359  Redacted form: plpsty(patt)\n\
10360 \n\
10361  This function is used in examples 12, 13, 15, 16, and 25.\n\
10362 \n\
10363 \n\
10364 \n\
10365 SYNOPSIS:\n\
10366 \n\
10367 plpsty(patt)\n\
10368 \n\
10369 ARGUMENTS:\n\
10370 \n\
10371  patt (PLINT, input) : The desired pattern index. If\n\
10372  patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10373  above) used. For\n\
10374  patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10375  line fill capability itself (most deliberately do not so that line\n\
10376  fill patterns look identical for those drivers), the patterns\n\
10377  consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10378  45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10379  lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10380  (8) lines at both 45 degrees and -45 degrees.\n\
10381 ";
10382 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10383 Set symbol size\n\
10384 \n\
10385 DESCRIPTION:\n\
10386 \n\
10387  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10388  plsym. The actual height of a symbol is the product of the default\n\
10389  symbol size and a scaling factor as for the character height.\n\
10390 \n\
10391  Redacted form: plssym(def, scale)\n\
10392 \n\
10393  This function is used in example 29.\n\
10394 \n\
10395 \n\
10396 \n\
10397 SYNOPSIS:\n\
10398 \n\
10399 plssym(def, scale)\n\
10400 \n\
10401 ARGUMENTS:\n\
10402 \n\
10403  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10404  should be set to zero if the default height is to remain\n\
10405  unchanged.\n\
10406 \n\
10407  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10408  actual symbol height.\n\
10409 ";
10410 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10411 Initialization\n\
10412 \n\
10413 DESCRIPTION:\n\
10414 \n\
10415  Alternative to plstar for initializing the plotting package. The\n\
10416  device name keyword for the desired output device must be supplied as\n\
10417  an argument. These keywords are the same as those printed out by\n\
10418  plstar. If the requested device is not available, or if the input\n\
10419  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10420  is used. This routine also divides the output device page into nx by\n\
10421  ny subpages, each of which may be used independently. The subroutine\n\
10422  pladv is used to advance from one subpage to the next.\n\
10423 \n\
10424  Redacted form: General: plstart(devname, nx, ny)\n\
10425 \t Perl/PDL: plstart(nx, ny, devname)\n\
10426 \n\
10427 \n\
10428  This function is not used in any examples.\n\
10429 \n\
10430 \n\
10431 \n\
10432 SYNOPSIS:\n\
10433 \n\
10434 plstart(devname, nx, ny)\n\
10435 \n\
10436 ARGUMENTS:\n\
10437 \n\
10438  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10439  containing the device name keyword of the required output device.\n\
10440  If\n\
10441  devname is NULL or if the first character of the string is a ``?\'\',\n\
10442  the normal (prompted) start up is used.\n\
10443 \n\
10444  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10445  x direction.\n\
10446 \n\
10447  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10448  y direction.\n\
10449 ";
10450 
10451 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10452  PLINT arg1 ;
10453  PLINT *arg2 = (PLINT *) 0 ;
10454  char **arg3 = (char **) 0 ;
10455  Matrix temp1 ;
10456  octave_value_list _out;
10457  octave_value_list *_outp=&_out;
10458  octave_value _outv;
10459 
10460  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10461  SWIG_fail;
10462  }
10463  {
10464  if ( _n_dims( args(0) ) > 1 )
10465  {
10466  error( "argument must be a scalar or vector" ); SWIG_fail;
10467  }
10468  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10469  arg2 = new PLINT[Alen];
10470  temp1 = args(0).matrix_value();
10471  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10472  }
10473  {
10474  charMatrix temp_matrix;
10475  Cell temp_cell;
10476  char *tmp_cstring;
10477  std::string str;
10478  size_t max_length = 0, non_blank_length;
10479  int i, ifcell;
10480  if ( _n_dims( args(1) ) > 2 )
10481  {
10482  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10483  }
10484  if ( !args(1).is_empty() )
10485  {
10486  if ( _dim( args(1), 0 ) != Alen )
10487  {
10488  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10489  }
10490  arg3 = new char*[Alen];
10491  ifcell = args(1).is_cell();
10492  if ( ifcell )
10493  {
10494  temp_cell = args(1).cell_value();
10495  }
10496  else
10497  {
10498  temp_matrix = args(1).char_matrix_value();
10499  // Allow one extra space for null termination.
10500  max_length = _dim( args(1), 1 ) + 1;
10501  }
10502 
10503  for ( i = 0; i < Alen; i++ )
10504  {
10505  // Must copy string to "permanent" location because the string
10506  // location corresponding to tmp_cstring gets
10507  // overwritten for each iteration of loop.
10508  if ( ifcell )
10509  {
10510  if ( temp_cell.elem( i ).is_string() )
10511  {
10512  str = temp_cell.elem( i ).string_value();
10513  // leave room for null termination.
10514  max_length = str.size() + 1;
10515  tmp_cstring = (char *) str.c_str();
10516  }
10517  else
10518  {
10519  // Use null string if user attempts to pass a cell array
10520  // with a non-string element (likely an empty element
10521  // since that should be allowed by the PLplot interface
10522  // if that element is going to be unused).
10523  // leave room for null termination.
10524  max_length = 1;
10525  tmp_cstring = (char *) "";
10526  }
10527  }
10528  else
10529  {
10530  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
10531  }
10532  arg3[i] = new char[max_length];
10533  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10534  arg3[i][max_length - 1] = '\0';
10535  // All the trailing blank crapola should not be needed for
10536  // string cell arrays.
10537  if ( !ifcell )
10538  {
10539  // remove trailing-blank padding that is used by the
10540  // charMatrix class to insure all strings in a given
10541  // charMatrix instance have the same length.
10542  // This transformation also removes legitimate trailing
10543  // blanks but there is nothing we can do about that
10544  // for the charMatrix class.
10545 
10546  // Look for trailing nulls first (just in case, although that
10547  // shouldn't happen if charMatrix implemented as documented)
10548  // before looking for trailing blanks.
10549  non_blank_length = max_length - 2;
10550  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10551  {
10552  non_blank_length--;
10553  }
10554  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10555  {
10556  non_blank_length--;
10557  }
10558  arg3[i][non_blank_length + 1] = '\0';
10559  }
10560  }
10561  }
10562  else
10563  {
10564  arg3 = NULL;
10565  }
10566  }
10567  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10568  _outv = octave_value();
10569  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10570  {
10571  delete [] arg2;
10572  }
10573  {
10574  int i;
10575  if ( arg3 != NULL )
10576  {
10577  for ( i = 0; i < Alen; i++ )
10578  {
10579  delete[] arg3[i];
10580  }
10581  delete[] arg3;
10582  }
10583  }
10584  return _out;
10585 fail:
10586  {
10587  delete [] arg2;
10588  }
10589  {
10590  int i;
10591  if ( arg3 != NULL )
10592  {
10593  for ( i = 0; i < Alen; i++ )
10594  {
10595  delete[] arg3[i];
10596  }
10597  delete[] arg3;
10598  }
10599  }
10600  return octave_value_list();
10601 }
10602 
10603 
10604 SWIG_DEFUN( plGetCursor, _wrap_plGetCursor, _wrap_plGetCursor_texinfo ) {
10605  int *arg1 = (int *) 0 ;
10606  int *arg2 = (int *) 0 ;
10607  int *arg3 = (int *) 0 ;
10608  char *arg4 = (char *) 0 ;
10609  int *arg5 = (int *) 0 ;
10610  int *arg6 = (int *) 0 ;
10611  PLFLT *arg7 = (PLFLT *) 0 ;
10612  PLFLT *arg8 = (PLFLT *) 0 ;
10613  PLFLT *arg9 = (PLFLT *) 0 ;
10614  PLFLT *arg10 = (PLFLT *) 0 ;
10615  int *arg11 = (int *) 0 ;
10616  int temp1 ;
10617  int res1 = SWIG_TMPOBJ ;
10618  int temp2 ;
10619  int res2 = SWIG_TMPOBJ ;
10620  int temp3 ;
10621  int res3 = SWIG_TMPOBJ ;
10622  octave_value_list retval4 ;
10623  int temp5 ;
10624  int res5 = SWIG_TMPOBJ ;
10625  int temp6 ;
10626  int res6 = SWIG_TMPOBJ ;
10627  PLFLT temp7 ;
10628  int res7 = SWIG_TMPOBJ ;
10629  PLFLT temp8 ;
10630  int res8 = SWIG_TMPOBJ ;
10631  PLFLT temp9 ;
10632  int res9 = SWIG_TMPOBJ ;
10633  PLFLT temp10 ;
10634  int res10 = SWIG_TMPOBJ ;
10635  int temp11 ;
10636  int res11 = SWIG_TMPOBJ ;
10637  octave_value_list _out;
10638  octave_value_list *_outp=&_out;
10639  octave_value _outv;
10640  int result;
10641 
10642  arg1 = &temp1;
10643  arg2 = &temp2;
10644  arg3 = &temp3;
10645  {
10646  // Check if version >= 3.4.0
10647 # if OCTAVE_API_VERSION_NUMBER < 45
10648  retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
10649 # else
10650  retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
10651 # endif
10652  arg4 = (char *) retval4( 0 ).char_matrix_value().data();
10653  }
10654  arg5 = &temp5;
10655  arg6 = &temp6;
10656  arg7 = &temp7;
10657  arg8 = &temp8;
10658  arg9 = &temp9;
10659  arg10 = &temp10;
10660  arg11 = &temp11;
10661  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10662  SWIG_fail;
10663  }
10664  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10665  _outv = SWIG_From_int((int)(result));
10666  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10667  if (SWIG_IsTmpObj(res1)) {
10668  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10669  } else {
10670  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10671  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10672  }
10673  if (SWIG_IsTmpObj(res2)) {
10674  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10675  } else {
10676  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10677  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10678  }
10679  if (SWIG_IsTmpObj(res3)) {
10680  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10681  } else {
10682  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10683  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
10684  }
10685  {
10686  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
10687  }
10688  if (SWIG_IsTmpObj(res5)) {
10689  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
10690  } else {
10691  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10692  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
10693  }
10694  if (SWIG_IsTmpObj(res6)) {
10695  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
10696  } else {
10697  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10698  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
10699  }
10700  if (SWIG_IsTmpObj(res7)) {
10701  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
10702  } else {
10703  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10704  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
10705  }
10706  if (SWIG_IsTmpObj(res8)) {
10707  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
10708  } else {
10709  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10710  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
10711  }
10712  if (SWIG_IsTmpObj(res9)) {
10713  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
10714  } else {
10715  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10716  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
10717  }
10718  if (SWIG_IsTmpObj(res10)) {
10719  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
10720  } else {
10721  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10722  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
10723  }
10724  if (SWIG_IsTmpObj(res11)) {
10725  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
10726  } else {
10727  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10728  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
10729  }
10730  return _out;
10731 fail:
10732  return octave_value_list();
10733 }
10734 
10735 
10736 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
10737  PLFLT *arg1 = (PLFLT *) 0 ;
10738  PLFLT *arg2 = (PLFLT *) 0 ;
10739  PLFLT arg3 ;
10740  PLFLT arg4 ;
10741  PLFLT temp1 ;
10742  int res1 = SWIG_TMPOBJ ;
10743  PLFLT temp2 ;
10744  int res2 = SWIG_TMPOBJ ;
10745  double val3 ;
10746  int ecode3 = 0 ;
10747  double val4 ;
10748  int ecode4 = 0 ;
10749  octave_value_list _out;
10750  octave_value_list *_outp=&_out;
10751  octave_value _outv;
10752  int result;
10753 
10754  arg1 = &temp1;
10755  arg2 = &temp2;
10756  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
10757  SWIG_fail;
10758  }
10759  ecode3 = SWIG_AsVal_double(args(0), &val3);
10760  if (!SWIG_IsOK(ecode3)) {
10761  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
10762  }
10763  arg3 = (PLFLT)(val3);
10764  ecode4 = SWIG_AsVal_double(args(1), &val4);
10765  if (!SWIG_IsOK(ecode4)) {
10766  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
10767  }
10768  arg4 = (PLFLT)(val4);
10769  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
10770  _outv = SWIG_From_int((int)(result));
10771  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10772  if (SWIG_IsTmpObj(res1)) {
10773  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
10774  } else {
10775  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10776  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10777  }
10778  if (SWIG_IsTmpObj(res2)) {
10779  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
10780  } else {
10781  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10782  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10783  }
10784  return _out;
10785 fail:
10786  return octave_value_list();
10787 }
10788 
10789 
10790 SWIG_DEFUN( plstripc, _wrap_plstripc, _wrap_plstripc_texinfo ) {
10791  PLINT *arg1 = (PLINT *) 0 ;
10792  char *arg2 = (char *) 0 ;
10793  char *arg3 = (char *) 0 ;
10794  PLFLT arg4 ;
10795  PLFLT arg5 ;
10796  PLFLT arg6 ;
10797  PLFLT arg7 ;
10798  PLFLT arg8 ;
10799  PLFLT arg9 ;
10800  PLFLT arg10 ;
10801  PLBOOL arg11 ;
10802  PLBOOL arg12 ;
10803  PLINT arg13 ;
10804  PLINT arg14 ;
10805  PLINT *arg15 = (PLINT *) 0 ;
10806  PLINT *arg16 = (PLINT *) 0 ;
10807  char *arg17 = (char *) 0 ;
10808  char *arg18 = (char *) 0 ;
10809  char *arg19 = (char *) 0 ;
10810  char *arg20 = (char *) 0 ;
10811  char *arg21 = (char *) 0 ;
10812  char *arg22 = (char *) 0 ;
10813  char *arg23 = (char *) 0 ;
10814  PLINT temp1 ;
10815  int res1 = SWIG_TMPOBJ ;
10816  int res2 ;
10817  char *buf2 = 0 ;
10818  int alloc2 = 0 ;
10819  int res3 ;
10820  char *buf3 = 0 ;
10821  int alloc3 = 0 ;
10822  double val4 ;
10823  int ecode4 = 0 ;
10824  double val5 ;
10825  int ecode5 = 0 ;
10826  double val6 ;
10827  int ecode6 = 0 ;
10828  double val7 ;
10829  int ecode7 = 0 ;
10830  double val8 ;
10831  int ecode8 = 0 ;
10832  double val9 ;
10833  int ecode9 = 0 ;
10834  double val10 ;
10835  int ecode10 = 0 ;
10836  int val11 ;
10837  int ecode11 = 0 ;
10838  int val12 ;
10839  int ecode12 = 0 ;
10840  int val13 ;
10841  int ecode13 = 0 ;
10842  int val14 ;
10843  int ecode14 = 0 ;
10844  Matrix temp15 ;
10845  Matrix temp16 ;
10846  int res17 ;
10847  char *buf17 = 0 ;
10848  int alloc17 = 0 ;
10849  int res18 ;
10850  char *buf18 = 0 ;
10851  int alloc18 = 0 ;
10852  int res19 ;
10853  char *buf19 = 0 ;
10854  int alloc19 = 0 ;
10855  int res20 ;
10856  char *buf20 = 0 ;
10857  int alloc20 = 0 ;
10858  int res21 ;
10859  char *buf21 = 0 ;
10860  int alloc21 = 0 ;
10861  int res22 ;
10862  char *buf22 = 0 ;
10863  int alloc22 = 0 ;
10864  int res23 ;
10865  char *buf23 = 0 ;
10866  int alloc23 = 0 ;
10867  octave_value_list _out;
10868  octave_value_list *_outp=&_out;
10869  octave_value _outv;
10870 
10871  arg1 = &temp1;
10872  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
10873  SWIG_fail;
10874  }
10875  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
10876  if (!SWIG_IsOK(res2)) {
10877  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
10878  }
10879  arg2 = (char *)(buf2);
10880  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
10881  if (!SWIG_IsOK(res3)) {
10882  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
10883  }
10884  arg3 = (char *)(buf3);
10885  ecode4 = SWIG_AsVal_double(args(2), &val4);
10886  if (!SWIG_IsOK(ecode4)) {
10887  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
10888  }
10889  arg4 = (PLFLT)(val4);
10890  ecode5 = SWIG_AsVal_double(args(3), &val5);
10891  if (!SWIG_IsOK(ecode5)) {
10892  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
10893  }
10894  arg5 = (PLFLT)(val5);
10895  ecode6 = SWIG_AsVal_double(args(4), &val6);
10896  if (!SWIG_IsOK(ecode6)) {
10897  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
10898  }
10899  arg6 = (PLFLT)(val6);
10900  ecode7 = SWIG_AsVal_double(args(5), &val7);
10901  if (!SWIG_IsOK(ecode7)) {
10902  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
10903  }
10904  arg7 = (PLFLT)(val7);
10905  ecode8 = SWIG_AsVal_double(args(6), &val8);
10906  if (!SWIG_IsOK(ecode8)) {
10907  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
10908  }
10909  arg8 = (PLFLT)(val8);
10910  ecode9 = SWIG_AsVal_double(args(7), &val9);
10911  if (!SWIG_IsOK(ecode9)) {
10912  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
10913  }
10914  arg9 = (PLFLT)(val9);
10915  ecode10 = SWIG_AsVal_double(args(8), &val10);
10916  if (!SWIG_IsOK(ecode10)) {
10917  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
10918  }
10919  arg10 = (PLFLT)(val10);
10920  ecode11 = SWIG_AsVal_int(args(9), &val11);
10921  if (!SWIG_IsOK(ecode11)) {
10922  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
10923  }
10924  arg11 = (PLBOOL)(val11);
10925  ecode12 = SWIG_AsVal_int(args(10), &val12);
10926  if (!SWIG_IsOK(ecode12)) {
10927  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
10928  }
10929  arg12 = (PLBOOL)(val12);
10930  ecode13 = SWIG_AsVal_int(args(11), &val13);
10931  if (!SWIG_IsOK(ecode13)) {
10932  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
10933  }
10934  arg13 = (PLINT)(val13);
10935  ecode14 = SWIG_AsVal_int(args(12), &val14);
10936  if (!SWIG_IsOK(ecode14)) {
10937  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
10938  }
10939  arg14 = (PLINT)(val14);
10940  {
10941  if ( _n_dims( args(13) ) > 1 )
10942  {
10943  error( "argument must be a scalar or vector" ); SWIG_fail;
10944  }
10945  Alen = (PLINT) ( _dim( args(13), 0 ) );
10946  temp15 = args(13).matrix_value();
10947  arg15 = new PLINT[Alen];
10948  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
10949  }
10950  {
10951  if ( _n_dims( args(14) ) > 1 )
10952  {
10953  error( "argument must be a scalar or vector" ); SWIG_fail;
10954  }
10955  if ( _dim( args(14), 0 ) != Alen )
10956  {
10957  error( "argument vectors must be same length" ); SWIG_fail;
10958  }
10959  temp16 = args(14).matrix_value();
10960  arg16 = new PLINT[Alen];
10961  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
10962  }
10963  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
10964  if (!SWIG_IsOK(res17)) {
10965  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
10966  }
10967  arg17 = (char *)(buf17);
10968  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
10969  if (!SWIG_IsOK(res18)) {
10970  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
10971  }
10972  arg18 = (char *)(buf18);
10973  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
10974  if (!SWIG_IsOK(res19)) {
10975  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
10976  }
10977  arg19 = (char *)(buf19);
10978  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
10979  if (!SWIG_IsOK(res20)) {
10980  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
10981  }
10982  arg20 = (char *)(buf20);
10983  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
10984  if (!SWIG_IsOK(res21)) {
10985  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
10986  }
10987  arg21 = (char *)(buf21);
10988  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
10989  if (!SWIG_IsOK(res22)) {
10990  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
10991  }
10992  arg22 = (char *)(buf22);
10993  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
10994  if (!SWIG_IsOK(res23)) {
10995  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
10996  }
10997  arg23 = (char *)(buf23);
10998  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);
10999  _outv = octave_value();
11000  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11001  if (SWIG_IsTmpObj(res1)) {
11002  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11003  } else {
11004  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11005  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11006  }
11007  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11008  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11009  {
11010  delete [] arg15;
11011  }
11012  {
11013  delete [] arg16;
11014  }
11015  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11016  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11017  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11018  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11019  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11020  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11021  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11022  return _out;
11023 fail:
11024  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11025  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11026  {
11027  delete [] arg15;
11028  }
11029  {
11030  delete [] arg16;
11031  }
11032  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11033  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11034  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11035  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11036  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11037  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11038  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11039  return octave_value_list();
11040 }
11041 
11042 
11043 SWIG_DEFUN( plcont, _wrap_plcont, _wrap_plcont_texinfo ) {
11044  PLFLT *arg1 = (PLFLT *) 0 ;
11045  PLINT arg2 ;
11046  PLINT arg3 ;
11047  PLINT arg4 ;
11048  PLINT arg5 ;
11049  PLINT arg6 ;
11050  PLINT arg7 ;
11051  PLFLT *arg8 = (PLFLT *) 0 ;
11052  PLINT arg9 ;
11053  PLFLT *arg10 = (PLFLT *) 0 ;
11054  Matrix temp1 ;
11055  int val4 ;
11056  int ecode4 = 0 ;
11057  int val5 ;
11058  int ecode5 = 0 ;
11059  int val6 ;
11060  int ecode6 = 0 ;
11061  int val7 ;
11062  int ecode7 = 0 ;
11063  Matrix temp8 ;
11064  Matrix temp10 ;
11065  octave_value_list _out;
11066  octave_value_list *_outp=&_out;
11067  octave_value _outv;
11068 
11069  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11070  SWIG_fail;
11071  }
11072  {
11073  if ( _n_dims( args(0) ) > 2 )
11074  {
11075  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11076  }
11077  temp1 = args(0).matrix_value();
11078  arg1 = &temp1( 0, 0 );
11079  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11080  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11081  }
11082  ecode4 = SWIG_AsVal_int(args(1), &val4);
11083  if (!SWIG_IsOK(ecode4)) {
11084  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11085  }
11086  arg4 = (PLINT)(val4);
11087  ecode5 = SWIG_AsVal_int(args(2), &val5);
11088  if (!SWIG_IsOK(ecode5)) {
11089  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11090  }
11091  arg5 = (PLINT)(val5);
11092  ecode6 = SWIG_AsVal_int(args(3), &val6);
11093  if (!SWIG_IsOK(ecode6)) {
11094  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11095  }
11096  arg6 = (PLINT)(val6);
11097  ecode7 = SWIG_AsVal_int(args(4), &val7);
11098  if (!SWIG_IsOK(ecode7)) {
11099  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11100  }
11101  arg7 = (PLINT)(val7);
11102  {
11103  if ( _n_dims( args(5) ) > 1 )
11104  {
11105  error( "argument must be a scalar or vector" ); SWIG_fail;
11106  }
11107  temp8 = args(5).matrix_value();
11108  arg8 = &temp8( 0, 0 );
11109  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11110  }
11111  {
11112  if ( _n_dims( args(6) ) > 1 )
11113  {
11114  error( "argument must be a scalar or vector" ); SWIG_fail;
11115  }
11116  if ( _dim( args(6), 0 ) != 6 )
11117  {
11118  error( "argument vectors must have length of 6" ); SWIG_fail;
11119  }
11120  temp10 = args(6).matrix_value();
11121  arg10 = &temp10( 0, 0 );
11122  }
11123  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11124  _outv = octave_value();
11125  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11126  {
11127 
11128  }
11129  {
11130 
11131  }
11132  {
11133 
11134  }
11135  return _out;
11136 fail:
11137  {
11138 
11139  }
11140  {
11141 
11142  }
11143  {
11144 
11145  }
11146  return octave_value_list();
11147 }
11148 
11149 
11150 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11151  PLFLT *arg1 = (PLFLT *) 0 ;
11152  PLINT arg2 ;
11153  PLINT arg3 ;
11154  PLINT arg4 ;
11155  PLINT arg5 ;
11156  PLINT arg6 ;
11157  PLINT arg7 ;
11158  PLFLT *arg8 = (PLFLT *) 0 ;
11159  PLINT arg9 ;
11160  Matrix temp1 ;
11161  int val4 ;
11162  int ecode4 = 0 ;
11163  int val5 ;
11164  int ecode5 = 0 ;
11165  int val6 ;
11166  int ecode6 = 0 ;
11167  int val7 ;
11168  int ecode7 = 0 ;
11169  Matrix temp8 ;
11170  octave_value_list _out;
11171  octave_value_list *_outp=&_out;
11172  octave_value _outv;
11173 
11174  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11175  SWIG_fail;
11176  }
11177  {
11178  if ( _n_dims( args(0) ) > 2 )
11179  {
11180  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11181  }
11182  temp1 = args(0).matrix_value();
11183  arg1 = &temp1( 0, 0 );
11184  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11185  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11186  }
11187  ecode4 = SWIG_AsVal_int(args(1), &val4);
11188  if (!SWIG_IsOK(ecode4)) {
11189  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11190  }
11191  arg4 = (PLINT)(val4);
11192  ecode5 = SWIG_AsVal_int(args(2), &val5);
11193  if (!SWIG_IsOK(ecode5)) {
11194  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11195  }
11196  arg5 = (PLINT)(val5);
11197  ecode6 = SWIG_AsVal_int(args(3), &val6);
11198  if (!SWIG_IsOK(ecode6)) {
11199  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11200  }
11201  arg6 = (PLINT)(val6);
11202  ecode7 = SWIG_AsVal_int(args(4), &val7);
11203  if (!SWIG_IsOK(ecode7)) {
11204  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11205  }
11206  arg7 = (PLINT)(val7);
11207  {
11208  if ( _n_dims( args(5) ) > 1 )
11209  {
11210  error( "argument must be a scalar or vector" ); SWIG_fail;
11211  }
11212  temp8 = args(5).matrix_value();
11213  arg8 = &temp8( 0, 0 );
11214  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11215  }
11216  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11217  _outv = octave_value();
11218  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11219  {
11220 
11221  }
11222  {
11223 
11224  }
11225  return _out;
11226 fail:
11227  {
11228 
11229  }
11230  {
11231 
11232  }
11233  return octave_value_list();
11234 }
11235 
11236 
11237 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11238  PLFLT *arg1 = (PLFLT *) 0 ;
11239  PLINT arg2 ;
11240  PLINT arg3 ;
11241  PLINT arg4 ;
11242  PLINT arg5 ;
11243  PLINT arg6 ;
11244  PLINT arg7 ;
11245  PLFLT *arg8 = (PLFLT *) 0 ;
11246  PLINT arg9 ;
11247  PLFLT *arg10 = (PLFLT *) 0 ;
11248  PLFLT *arg11 = (PLFLT *) 0 ;
11249  Matrix temp1 ;
11250  int val4 ;
11251  int ecode4 = 0 ;
11252  int val5 ;
11253  int ecode5 = 0 ;
11254  int val6 ;
11255  int ecode6 = 0 ;
11256  int val7 ;
11257  int ecode7 = 0 ;
11258  Matrix temp8 ;
11259  Matrix temp10 ;
11260  Matrix temp11 ;
11261  octave_value_list _out;
11262  octave_value_list *_outp=&_out;
11263  octave_value _outv;
11264 
11265  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11266  SWIG_fail;
11267  }
11268  {
11269  if ( _n_dims( args(0) ) > 2 )
11270  {
11271  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11272  }
11273  temp1 = args(0).matrix_value();
11274  arg1 = &temp1( 0, 0 );
11275  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11276  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11277  }
11278  ecode4 = SWIG_AsVal_int(args(1), &val4);
11279  if (!SWIG_IsOK(ecode4)) {
11280  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11281  }
11282  arg4 = (PLINT)(val4);
11283  ecode5 = SWIG_AsVal_int(args(2), &val5);
11284  if (!SWIG_IsOK(ecode5)) {
11285  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11286  }
11287  arg5 = (PLINT)(val5);
11288  ecode6 = SWIG_AsVal_int(args(3), &val6);
11289  if (!SWIG_IsOK(ecode6)) {
11290  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11291  }
11292  arg6 = (PLINT)(val6);
11293  ecode7 = SWIG_AsVal_int(args(4), &val7);
11294  if (!SWIG_IsOK(ecode7)) {
11295  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11296  }
11297  arg7 = (PLINT)(val7);
11298  {
11299  if ( _n_dims( args(5) ) > 1 )
11300  {
11301  error( "argument must be a scalar or vector" ); SWIG_fail;
11302  }
11303  temp8 = args(5).matrix_value();
11304  arg8 = &temp8( 0, 0 );
11305  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11306  }
11307  {
11308  if ( _n_dims( args(6) ) > 1 )
11309  {
11310  error( "argument must be a scalar or vector" ); SWIG_fail;
11311  }
11312  if ( _dim( args(6), 0 ) != Xlen )
11313  {
11314  error( "argument vectors must be same length" ); SWIG_fail;
11315  }
11316  temp10 = args(6).matrix_value();
11317  arg10 = &temp10( 0, 0 );
11318  }
11319  {
11320  if ( _n_dims( args(7) ) > 1 )
11321  {
11322  error( "argument must be a scalar or vector" ); SWIG_fail;
11323  }
11324  if ( _dim( args(7), 0 ) != Ylen )
11325  {
11326  error( "argument vectors must be same length" ); SWIG_fail;
11327  }
11328  temp11 = args(7).matrix_value();
11329  arg11 = &temp11( 0, 0 );
11330  }
11331  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11332  _outv = octave_value();
11333  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11334  {
11335 
11336  }
11337  {
11338 
11339  }
11340  {
11341 
11342  }
11343  {
11344 
11345  }
11346  return _out;
11347 fail:
11348  {
11349 
11350  }
11351  {
11352 
11353  }
11354  {
11355 
11356  }
11357  {
11358 
11359  }
11360  return octave_value_list();
11361 }
11362 
11363 
11364 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11365  PLFLT *arg1 = (PLFLT *) 0 ;
11366  PLINT arg2 ;
11367  PLINT arg3 ;
11368  PLINT arg4 ;
11369  PLINT arg5 ;
11370  PLINT arg6 ;
11371  PLINT arg7 ;
11372  PLFLT *arg8 = (PLFLT *) 0 ;
11373  PLINT arg9 ;
11374  PLFLT *arg10 = (PLFLT *) 0 ;
11375  PLFLT *arg11 = (PLFLT *) 0 ;
11376  Matrix temp1 ;
11377  int val4 ;
11378  int ecode4 = 0 ;
11379  int val5 ;
11380  int ecode5 = 0 ;
11381  int val6 ;
11382  int ecode6 = 0 ;
11383  int val7 ;
11384  int ecode7 = 0 ;
11385  Matrix temp8 ;
11386  Matrix temp10 ;
11387  Matrix temp11 ;
11388  octave_value_list _out;
11389  octave_value_list *_outp=&_out;
11390  octave_value _outv;
11391 
11392  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11393  SWIG_fail;
11394  }
11395  {
11396  if ( _n_dims( args(0) ) > 2 )
11397  {
11398  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11399  }
11400  temp1 = args(0).matrix_value();
11401  arg1 = &temp1( 0, 0 );
11402  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11403  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11404  }
11405  ecode4 = SWIG_AsVal_int(args(1), &val4);
11406  if (!SWIG_IsOK(ecode4)) {
11407  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11408  }
11409  arg4 = (PLINT)(val4);
11410  ecode5 = SWIG_AsVal_int(args(2), &val5);
11411  if (!SWIG_IsOK(ecode5)) {
11412  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11413  }
11414  arg5 = (PLINT)(val5);
11415  ecode6 = SWIG_AsVal_int(args(3), &val6);
11416  if (!SWIG_IsOK(ecode6)) {
11417  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11418  }
11419  arg6 = (PLINT)(val6);
11420  ecode7 = SWIG_AsVal_int(args(4), &val7);
11421  if (!SWIG_IsOK(ecode7)) {
11422  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11423  }
11424  arg7 = (PLINT)(val7);
11425  {
11426  if ( _n_dims( args(5) ) > 1 )
11427  {
11428  error( "argument must be a scalar or vector" ); SWIG_fail;
11429  }
11430  temp8 = args(5).matrix_value();
11431  arg8 = &temp8( 0, 0 );
11432  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11433  }
11434  {
11435  if ( _n_dims( args(6) ) > 2 )
11436  {
11437  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11438  }
11439  if ( _dim( args(6), 0 ) != Xlen )
11440  {
11441  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11442  }
11443  if ( _dim( args(6), 1 ) != Ylen )
11444  {
11445  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11446  }
11447  temp10 = args(6).matrix_value();
11448  arg10 = &temp10( 0, 0 );
11449  }
11450  {
11451  if ( _n_dims( args(7) ) > 2 )
11452  {
11453  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11454  }
11455  if ( _dim( args(7), 0 ) != Xlen )
11456  {
11457  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11458  }
11459  if ( _dim( args(7), 1 ) != Ylen )
11460  {
11461  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11462  }
11463  temp11 = args(7).matrix_value();
11464  arg11 = &temp11( 0, 0 );
11465  }
11466  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11467  _outv = octave_value();
11468  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11469  {
11470 
11471  }
11472  {
11473 
11474  }
11475  {
11476 
11477  }
11478  {
11479 
11480  }
11481  return _out;
11482 fail:
11483  {
11484 
11485  }
11486  {
11487 
11488  }
11489  {
11490 
11491  }
11492  {
11493 
11494  }
11495  return octave_value_list();
11496 }
11497 
11498 
11499 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11500  PLFLT *arg1 = (PLFLT *) 0 ;
11501  PLINT arg2 ;
11502  PLINT arg3 ;
11503  PLINT arg4 ;
11504  PLINT arg5 ;
11505  PLINT arg6 ;
11506  PLINT arg7 ;
11507  PLFLT *arg8 = (PLFLT *) 0 ;
11508  PLINT arg9 ;
11509  PLFLT *arg10 = (PLFLT *) 0 ;
11510  PLFLT *arg11 = (PLFLT *) 0 ;
11511  Matrix temp1 ;
11512  int val4 ;
11513  int ecode4 = 0 ;
11514  int val5 ;
11515  int ecode5 = 0 ;
11516  int val6 ;
11517  int ecode6 = 0 ;
11518  int val7 ;
11519  int ecode7 = 0 ;
11520  Matrix temp8 ;
11521  Matrix temp10 ;
11522  Matrix temp11 ;
11523  octave_value_list _out;
11524  octave_value_list *_outp=&_out;
11525  octave_value _outv;
11526 
11527  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11528  SWIG_fail;
11529  }
11530  {
11531  if ( _n_dims( args(0) ) > 2 )
11532  {
11533  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11534  }
11535  temp1 = args(0).matrix_value();
11536  arg1 = &temp1( 0, 0 );
11537  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11538  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11539  }
11540  ecode4 = SWIG_AsVal_int(args(1), &val4);
11541  if (!SWIG_IsOK(ecode4)) {
11542  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11543  }
11544  arg4 = (PLINT)(val4);
11545  ecode5 = SWIG_AsVal_int(args(2), &val5);
11546  if (!SWIG_IsOK(ecode5)) {
11547  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11548  }
11549  arg5 = (PLINT)(val5);
11550  ecode6 = SWIG_AsVal_int(args(3), &val6);
11551  if (!SWIG_IsOK(ecode6)) {
11552  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11553  }
11554  arg6 = (PLINT)(val6);
11555  ecode7 = SWIG_AsVal_int(args(4), &val7);
11556  if (!SWIG_IsOK(ecode7)) {
11557  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11558  }
11559  arg7 = (PLINT)(val7);
11560  {
11561  if ( _n_dims( args(5) ) > 1 )
11562  {
11563  error( "argument must be a scalar or vector" ); SWIG_fail;
11564  }
11565  temp8 = args(5).matrix_value();
11566  arg8 = &temp8( 0, 0 );
11567  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11568  }
11569  {
11570  if ( _n_dims( args(6) ) > 2 )
11571  {
11572  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11573  }
11574  if ( _dim( args(6), 0 ) != Xlen )
11575  {
11576  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11577  }
11578  if ( _dim( args(6), 1 ) != Ylen )
11579  {
11580  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11581  }
11582  temp10 = args(6).matrix_value();
11583  arg10 = &temp10( 0, 0 );
11584  }
11585  {
11586  if ( _n_dims( args(7) ) > 2 )
11587  {
11588  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11589  }
11590  if ( _dim( args(7), 0 ) != Xlen )
11591  {
11592  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11593  }
11594  if ( _dim( args(7), 1 ) != Ylen )
11595  {
11596  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11597  }
11598  temp11 = args(7).matrix_value();
11599  arg11 = &temp11( 0, 0 );
11600  }
11601  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11602  _outv = octave_value();
11603  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11604  {
11605 
11606  }
11607  {
11608 
11609  }
11610  {
11611 
11612  }
11613  {
11614 
11615  }
11616  return _out;
11617 fail:
11618  {
11619 
11620  }
11621  {
11622 
11623  }
11624  {
11625 
11626  }
11627  {
11628 
11629  }
11630  return octave_value_list();
11631 }
11632 
11633 
11634 SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
11635  PLFLT *arg1 = (PLFLT *) 0 ;
11636  PLFLT *arg2 = (PLFLT *) 0 ;
11637  PLFLT *arg3 = (PLFLT *) 0 ;
11638  PLINT arg4 ;
11639  PLFLT *arg5 = (PLFLT *) 0 ;
11640  PLINT arg6 ;
11641  PLFLT *arg7 = (PLFLT *) 0 ;
11642  PLINT arg8 ;
11643  PLFLT *arg9 = (PLFLT *) 0 ;
11644  PLINT arg10 ;
11645  PLFLT arg11 ;
11646  Matrix temp1 ;
11647  Matrix temp2 ;
11648  Matrix temp3 ;
11649  Matrix temp5 ;
11650  Matrix temp7 ;
11651  octave_value_list retval7 ;
11652  int val10 ;
11653  int ecode10 = 0 ;
11654  double val11 ;
11655  int ecode11 = 0 ;
11656  octave_value_list _out;
11657  octave_value_list *_outp=&_out;
11658  octave_value _outv;
11659 
11660  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11661  SWIG_fail;
11662  }
11663  {
11664  if ( _n_dims( args(0) ) > 1 )
11665  {
11666  error( "argument must be a scalar or vector" ); SWIG_fail;
11667  }
11668  Alen = (PLINT) ( _dim( args(0), 0 ) );
11669  temp1 = args(0).matrix_value();
11670  arg1 = &temp1( 0, 0 );
11671  }
11672  {
11673  if ( _n_dims( args(1) ) > 1 )
11674  {
11675  error( "argument must be a scalar or vector" ); SWIG_fail;
11676  }
11677  if ( _dim( args(1), 0 ) != Alen )
11678  {
11679  error( "argument vectors must be same length" ); SWIG_fail;
11680  }
11681  temp2 = args(1).matrix_value();
11682  arg2 = &temp2( 0, 0 );
11683  }
11684  {
11685  if ( _n_dims( args(2) ) > 1 )
11686  {
11687  error( "argument must be a scalar or vector" ); SWIG_fail;
11688  }
11689  if ( _dim( args(2), 0 ) != Alen )
11690  {
11691  error( "argument vectors must be same length" ); SWIG_fail;
11692  }
11693  temp3 = args(2).matrix_value();
11694  arg3 = &temp3( 0, 0 );
11695  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11696  }
11697  {
11698  if ( _n_dims( args(3) ) > 1 )
11699  {
11700  error( "argument must be a scalar or vector" ); SWIG_fail;
11701  }
11702  temp5 = args(3).matrix_value();
11703  arg5 = &temp5( 0, 0 );
11704  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
11705  }
11706  {
11707  if ( _n_dims( args(4) ) > 1 )
11708  {
11709  error( "argument must be a scalar or vector" ); SWIG_fail;
11710  }
11711  temp7 = args(4).matrix_value();
11712  arg7 = &temp7( 0, 0 );
11713  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
11714  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
11715  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
11716  }
11717  ecode10 = SWIG_AsVal_int(args(5), &val10);
11718  if (!SWIG_IsOK(ecode10)) {
11719  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
11720  }
11721  arg10 = (PLINT)(val10);
11722  ecode11 = SWIG_AsVal_double(args(6), &val11);
11723  if (!SWIG_IsOK(ecode11)) {
11724  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
11725  }
11726  arg11 = (PLFLT)(val11);
11727  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
11728  _outv = octave_value();
11729  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11730  {
11731  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
11732  }
11733  {
11734 
11735  }
11736  {
11737 
11738  }
11739  {
11740 
11741  }
11742  {
11743 
11744  }
11745  {
11746 
11747  }
11748  return _out;
11749 fail:
11750  {
11751 
11752  }
11753  {
11754 
11755  }
11756  {
11757 
11758  }
11759  {
11760 
11761  }
11762  {
11763 
11764  }
11765  return octave_value_list();
11766 }
11767 
11768 
11769 SWIG_DEFUN( plmesh, _wrap_plmesh, _wrap_plmesh_texinfo ) {
11770  PLFLT *arg1 = (PLFLT *) 0 ;
11771  PLFLT *arg2 = (PLFLT *) 0 ;
11772  PLFLT *arg3 = (PLFLT *) 0 ;
11773  PLINT arg4 ;
11774  PLINT arg5 ;
11775  PLINT arg6 ;
11776  Matrix temp1 ;
11777  Matrix temp2 ;
11778  Matrix temp3 ;
11779  int val6 ;
11780  int ecode6 = 0 ;
11781  octave_value_list _out;
11782  octave_value_list *_outp=&_out;
11783  octave_value _outv;
11784 
11785  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
11786  SWIG_fail;
11787  }
11788  {
11789  if ( _n_dims( args(0) ) > 1 )
11790  {
11791  error( "argument must be a scalar or vector" ); SWIG_fail;
11792  }
11793  temp1 = args(0).matrix_value();
11794  arg1 = &temp1( 0, 0 );
11795  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11796  }
11797  {
11798  if ( _n_dims( args(1) ) > 1 )
11799  {
11800  error( "argument must be a scalar or vector" ); SWIG_fail;
11801  }
11802  temp2 = args(1).matrix_value();
11803  arg2 = &temp2( 0, 0 );
11804  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11805  }
11806  {
11807  if ( _n_dims( args(2) ) > 2 )
11808  {
11809  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11810  }
11811  if ( _dim( args(2), 0 ) != Xlen )
11812  {
11813  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11814  }
11815  if ( _dim( args(2), 1 ) != Ylen )
11816  {
11817  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11818  }
11819  temp3 = args(2).matrix_value();
11820  arg3 = &temp3( 0, 0 );
11821  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11822  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11823  }
11824  ecode6 = SWIG_AsVal_int(args(3), &val6);
11825  if (!SWIG_IsOK(ecode6)) {
11826  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
11827  }
11828  arg6 = (PLINT)(val6);
11829  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
11830  _outv = octave_value();
11831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11832  {
11833 
11834  }
11835  {
11836 
11837  }
11838  {
11839 
11840  }
11841  return _out;
11842 fail:
11843  {
11844 
11845  }
11846  {
11847 
11848  }
11849  {
11850 
11851  }
11852  return octave_value_list();
11853 }
11854 
11855 
11856 SWIG_DEFUN( plmeshc, _wrap_plmeshc, _wrap_plmeshc_texinfo ) {
11857  PLFLT *arg1 = (PLFLT *) 0 ;
11858  PLFLT *arg2 = (PLFLT *) 0 ;
11859  PLFLT *arg3 = (PLFLT *) 0 ;
11860  PLINT arg4 ;
11861  PLINT arg5 ;
11862  PLINT arg6 ;
11863  PLFLT *arg7 = (PLFLT *) 0 ;
11864  PLINT arg8 ;
11865  Matrix temp1 ;
11866  Matrix temp2 ;
11867  Matrix temp3 ;
11868  int val6 ;
11869  int ecode6 = 0 ;
11870  Matrix temp7 ;
11871  octave_value_list _out;
11872  octave_value_list *_outp=&_out;
11873  octave_value _outv;
11874 
11875  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
11876  SWIG_fail;
11877  }
11878  {
11879  if ( _n_dims( args(0) ) > 1 )
11880  {
11881  error( "argument must be a scalar or vector" ); SWIG_fail;
11882  }
11883  temp1 = args(0).matrix_value();
11884  arg1 = &temp1( 0, 0 );
11885  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11886  }
11887  {
11888  if ( _n_dims( args(1) ) > 1 )
11889  {
11890  error( "argument must be a scalar or vector" ); SWIG_fail;
11891  }
11892  temp2 = args(1).matrix_value();
11893  arg2 = &temp2( 0, 0 );
11894  Ylen = (PLINT) ( _dim( args(1), 0 ) );
11895  }
11896  {
11897  if ( _n_dims( args(2) ) > 2 )
11898  {
11899  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11900  }
11901  if ( _dim( args(2), 0 ) != Xlen )
11902  {
11903  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11904  }
11905  if ( _dim( args(2), 1 ) != Ylen )
11906  {
11907  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11908  }
11909  temp3 = args(2).matrix_value();
11910  arg3 = &temp3( 0, 0 );
11911  arg4 = (PLINT) ( _dim( args(2), 0 ) );
11912  arg5 = (PLINT) ( _dim( args(2), 1 ) );
11913  }
11914  ecode6 = SWIG_AsVal_int(args(3), &val6);
11915  if (!SWIG_IsOK(ecode6)) {
11916  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
11917  }
11918  arg6 = (PLINT)(val6);
11919  {
11920  if ( _n_dims( args(4) ) > 1 )
11921  {
11922  error( "argument must be a scalar or vector" ); SWIG_fail;
11923  }
11924  temp7 = args(4).matrix_value();
11925  arg7 = &temp7( 0, 0 );
11926  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
11927  }
11928  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
11929  _outv = octave_value();
11930  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11931  {
11932 
11933  }
11934  {
11935 
11936  }
11937  {
11938 
11939  }
11940  {
11941 
11942  }
11943  return _out;
11944 fail:
11945  {
11946 
11947  }
11948  {
11949 
11950  }
11951  {
11952 
11953  }
11954  {
11955 
11956  }
11957  return octave_value_list();
11958 }
11959 
11960 
11961 SWIG_DEFUN( plot3d, _wrap_plot3d, _wrap_plot3d_texinfo ) {
11962  PLFLT *arg1 = (PLFLT *) 0 ;
11963  PLFLT *arg2 = (PLFLT *) 0 ;
11964  PLFLT *arg3 = (PLFLT *) 0 ;
11965  PLINT arg4 ;
11966  PLINT arg5 ;
11967  PLINT arg6 ;
11968  PLBOOL arg7 ;
11969  Matrix temp1 ;
11970  Matrix temp2 ;
11971  Matrix temp3 ;
11972  int val6 ;
11973  int ecode6 = 0 ;
11974  int val7 ;
11975  int ecode7 = 0 ;
11976  octave_value_list _out;
11977  octave_value_list *_outp=&_out;
11978  octave_value _outv;
11979 
11980  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
11981  SWIG_fail;
11982  }
11983  {
11984  if ( _n_dims( args(0) ) > 1 )
11985  {
11986  error( "argument must be a scalar or vector" ); SWIG_fail;
11987  }
11988  temp1 = args(0).matrix_value();
11989  arg1 = &temp1( 0, 0 );
11990  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11991  }
11992  {
11993  if ( _n_dims( args(1) ) > 1 )
11994  {
11995  error( "argument must be a scalar or vector" ); SWIG_fail;
11996  }
11997  temp2 = args(1).matrix_value();
11998  arg2 = &temp2( 0, 0 );
11999  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12000  }
12001  {
12002  if ( _n_dims( args(2) ) > 2 )
12003  {
12004  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12005  }
12006  if ( _dim( args(2), 0 ) != Xlen )
12007  {
12008  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12009  }
12010  if ( _dim( args(2), 1 ) != Ylen )
12011  {
12012  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12013  }
12014  temp3 = args(2).matrix_value();
12015  arg3 = &temp3( 0, 0 );
12016  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12017  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12018  }
12019  ecode6 = SWIG_AsVal_int(args(3), &val6);
12020  if (!SWIG_IsOK(ecode6)) {
12021  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12022  }
12023  arg6 = (PLINT)(val6);
12024  ecode7 = SWIG_AsVal_int(args(4), &val7);
12025  if (!SWIG_IsOK(ecode7)) {
12026  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12027  }
12028  arg7 = (PLBOOL)(val7);
12029  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12030  _outv = octave_value();
12031  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12032  {
12033 
12034  }
12035  {
12036 
12037  }
12038  {
12039 
12040  }
12041  return _out;
12042 fail:
12043  {
12044 
12045  }
12046  {
12047 
12048  }
12049  {
12050 
12051  }
12052  return octave_value_list();
12053 }
12054 
12055 
12056 SWIG_DEFUN( plot3dc, _wrap_plot3dc, _wrap_plot3dc_texinfo ) {
12057  PLFLT *arg1 = (PLFLT *) 0 ;
12058  PLFLT *arg2 = (PLFLT *) 0 ;
12059  PLFLT *arg3 = (PLFLT *) 0 ;
12060  PLINT arg4 ;
12061  PLINT arg5 ;
12062  PLINT arg6 ;
12063  PLFLT *arg7 = (PLFLT *) 0 ;
12064  PLINT arg8 ;
12065  Matrix temp1 ;
12066  Matrix temp2 ;
12067  Matrix temp3 ;
12068  int val6 ;
12069  int ecode6 = 0 ;
12070  Matrix temp7 ;
12071  octave_value_list _out;
12072  octave_value_list *_outp=&_out;
12073  octave_value _outv;
12074 
12075  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12076  SWIG_fail;
12077  }
12078  {
12079  if ( _n_dims( args(0) ) > 1 )
12080  {
12081  error( "argument must be a scalar or vector" ); SWIG_fail;
12082  }
12083  temp1 = args(0).matrix_value();
12084  arg1 = &temp1( 0, 0 );
12085  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12086  }
12087  {
12088  if ( _n_dims( args(1) ) > 1 )
12089  {
12090  error( "argument must be a scalar or vector" ); SWIG_fail;
12091  }
12092  temp2 = args(1).matrix_value();
12093  arg2 = &temp2( 0, 0 );
12094  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12095  }
12096  {
12097  if ( _n_dims( args(2) ) > 2 )
12098  {
12099  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12100  }
12101  if ( _dim( args(2), 0 ) != Xlen )
12102  {
12103  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12104  }
12105  if ( _dim( args(2), 1 ) != Ylen )
12106  {
12107  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12108  }
12109  temp3 = args(2).matrix_value();
12110  arg3 = &temp3( 0, 0 );
12111  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12112  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12113  }
12114  ecode6 = SWIG_AsVal_int(args(3), &val6);
12115  if (!SWIG_IsOK(ecode6)) {
12116  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12117  }
12118  arg6 = (PLINT)(val6);
12119  {
12120  if ( _n_dims( args(4) ) > 1 )
12121  {
12122  error( "argument must be a scalar or vector" ); SWIG_fail;
12123  }
12124  temp7 = args(4).matrix_value();
12125  arg7 = &temp7( 0, 0 );
12126  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12127  }
12128  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12129  _outv = octave_value();
12130  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12131  {
12132 
12133  }
12134  {
12135 
12136  }
12137  {
12138 
12139  }
12140  {
12141 
12142  }
12143  return _out;
12144 fail:
12145  {
12146 
12147  }
12148  {
12149 
12150  }
12151  {
12152 
12153  }
12154  {
12155 
12156  }
12157  return octave_value_list();
12158 }
12159 
12160 
12161 SWIG_DEFUN( plot3dcl, _wrap_plot3dcl, _wrap_plot3dcl_texinfo ) {
12162  PLFLT *arg1 = (PLFLT *) 0 ;
12163  PLFLT *arg2 = (PLFLT *) 0 ;
12164  PLFLT *arg3 = (PLFLT *) 0 ;
12165  PLINT arg4 ;
12166  PLINT arg5 ;
12167  PLINT arg6 ;
12168  PLFLT *arg7 = (PLFLT *) 0 ;
12169  PLINT arg8 ;
12170  PLINT arg9 ;
12171  PLINT arg10 ;
12172  PLINT *arg11 = (PLINT *) 0 ;
12173  PLINT *arg12 = (PLINT *) 0 ;
12174  Matrix temp1 ;
12175  Matrix temp2 ;
12176  Matrix temp3 ;
12177  int val6 ;
12178  int ecode6 = 0 ;
12179  Matrix temp7 ;
12180  int val9 ;
12181  int ecode9 = 0 ;
12182  Matrix temp10 ;
12183  Matrix temp12 ;
12184  octave_value_list _out;
12185  octave_value_list *_outp=&_out;
12186  octave_value _outv;
12187 
12188  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12189  SWIG_fail;
12190  }
12191  {
12192  if ( _n_dims( args(0) ) > 1 )
12193  {
12194  error( "argument must be a scalar or vector" ); SWIG_fail;
12195  }
12196  temp1 = args(0).matrix_value();
12197  arg1 = &temp1( 0, 0 );
12198  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12199  }
12200  {
12201  if ( _n_dims( args(1) ) > 1 )
12202  {
12203  error( "argument must be a scalar or vector" ); SWIG_fail;
12204  }
12205  temp2 = args(1).matrix_value();
12206  arg2 = &temp2( 0, 0 );
12207  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12208  }
12209  {
12210  if ( _n_dims( args(2) ) > 2 )
12211  {
12212  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12213  }
12214  if ( _dim( args(2), 0 ) != Xlen )
12215  {
12216  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12217  }
12218  if ( _dim( args(2), 1 ) != Ylen )
12219  {
12220  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12221  }
12222  temp3 = args(2).matrix_value();
12223  arg3 = &temp3( 0, 0 );
12224  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12225  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12226  }
12227  ecode6 = SWIG_AsVal_int(args(3), &val6);
12228  if (!SWIG_IsOK(ecode6)) {
12229  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12230  }
12231  arg6 = (PLINT)(val6);
12232  {
12233  if ( _n_dims( args(4) ) > 1 )
12234  {
12235  error( "argument must be a scalar or vector" ); SWIG_fail;
12236  }
12237  temp7 = args(4).matrix_value();
12238  arg7 = &temp7( 0, 0 );
12239  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12240  }
12241  ecode9 = SWIG_AsVal_int(args(5), &val9);
12242  if (!SWIG_IsOK(ecode9)) {
12243  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12244  }
12245  arg9 = (PLINT)(val9);
12246  {
12247  if ( _n_dims( args(6) ) > 1 )
12248  {
12249  error( "argument must be a scalar or vector" ); SWIG_fail;
12250  }
12251  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12252  arg11 = new PLINT[Alen];
12253  temp10 = args(6).matrix_value();
12254  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12255  }
12256  {
12257  if ( _n_dims( args(7) ) > 1 )
12258  {
12259  error( "argument must be a scalar or vector" ); SWIG_fail;
12260  }
12261  if ( _dim( args(7), 0 ) != Alen )
12262  {
12263  error( "argument vectors must be same length" ); SWIG_fail;
12264  }
12265  temp12 = args(7).matrix_value();
12266  arg12 = new PLINT[Alen];
12267  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12268  }
12269  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);
12270  _outv = octave_value();
12271  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12272  {
12273 
12274  }
12275  {
12276 
12277  }
12278  {
12279 
12280  }
12281  {
12282 
12283  }
12284  {
12285  delete [] arg11;
12286  }
12287  {
12288  delete [] arg12;
12289  }
12290  return _out;
12291 fail:
12292  {
12293 
12294  }
12295  {
12296 
12297  }
12298  {
12299 
12300  }
12301  {
12302 
12303  }
12304  {
12305  delete [] arg11;
12306  }
12307  {
12308  delete [] arg12;
12309  }
12310  return octave_value_list();
12311 }
12312 
12313 
12314 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, _wrap_plsurf3d_texinfo ) {
12315  PLFLT *arg1 = (PLFLT *) 0 ;
12316  PLFLT *arg2 = (PLFLT *) 0 ;
12317  PLFLT *arg3 = (PLFLT *) 0 ;
12318  PLINT arg4 ;
12319  PLINT arg5 ;
12320  PLINT arg6 ;
12321  PLFLT *arg7 = (PLFLT *) 0 ;
12322  PLINT arg8 ;
12323  Matrix temp1 ;
12324  Matrix temp2 ;
12325  Matrix temp3 ;
12326  int val6 ;
12327  int ecode6 = 0 ;
12328  Matrix temp7 ;
12329  octave_value_list _out;
12330  octave_value_list *_outp=&_out;
12331  octave_value _outv;
12332 
12333  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12334  SWIG_fail;
12335  }
12336  {
12337  if ( _n_dims( args(0) ) > 1 )
12338  {
12339  error( "argument must be a scalar or vector" ); SWIG_fail;
12340  }
12341  temp1 = args(0).matrix_value();
12342  arg1 = &temp1( 0, 0 );
12343  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12344  }
12345  {
12346  if ( _n_dims( args(1) ) > 1 )
12347  {
12348  error( "argument must be a scalar or vector" ); SWIG_fail;
12349  }
12350  temp2 = args(1).matrix_value();
12351  arg2 = &temp2( 0, 0 );
12352  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12353  }
12354  {
12355  if ( _n_dims( args(2) ) > 2 )
12356  {
12357  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12358  }
12359  if ( _dim( args(2), 0 ) != Xlen )
12360  {
12361  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12362  }
12363  if ( _dim( args(2), 1 ) != Ylen )
12364  {
12365  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12366  }
12367  temp3 = args(2).matrix_value();
12368  arg3 = &temp3( 0, 0 );
12369  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12370  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12371  }
12372  ecode6 = SWIG_AsVal_int(args(3), &val6);
12373  if (!SWIG_IsOK(ecode6)) {
12374  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
12375  }
12376  arg6 = (PLINT)(val6);
12377  {
12378  if ( _n_dims( args(4) ) > 1 )
12379  {
12380  error( "argument must be a scalar or vector" ); SWIG_fail;
12381  }
12382  temp7 = args(4).matrix_value();
12383  arg7 = &temp7( 0, 0 );
12384  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12385  }
12386  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12387  _outv = octave_value();
12388  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12389  {
12390 
12391  }
12392  {
12393 
12394  }
12395  {
12396 
12397  }
12398  {
12399 
12400  }
12401  return _out;
12402 fail:
12403  {
12404 
12405  }
12406  {
12407 
12408  }
12409  {
12410 
12411  }
12412  {
12413 
12414  }
12415  return octave_value_list();
12416 }
12417 
12418 
12419 SWIG_DEFUN( plsurf3dl, _wrap_plsurf3dl, _wrap_plsurf3dl_texinfo ) {
12420  PLFLT *arg1 = (PLFLT *) 0 ;
12421  PLFLT *arg2 = (PLFLT *) 0 ;
12422  PLFLT *arg3 = (PLFLT *) 0 ;
12423  PLINT arg4 ;
12424  PLINT arg5 ;
12425  PLINT arg6 ;
12426  PLFLT *arg7 = (PLFLT *) 0 ;
12427  PLINT arg8 ;
12428  PLINT arg9 ;
12429  PLINT arg10 ;
12430  PLINT *arg11 = (PLINT *) 0 ;
12431  PLINT *arg12 = (PLINT *) 0 ;
12432  Matrix temp1 ;
12433  Matrix temp2 ;
12434  Matrix temp3 ;
12435  int val6 ;
12436  int ecode6 = 0 ;
12437  Matrix temp7 ;
12438  int val9 ;
12439  int ecode9 = 0 ;
12440  Matrix temp10 ;
12441  Matrix temp12 ;
12442  octave_value_list _out;
12443  octave_value_list *_outp=&_out;
12444  octave_value _outv;
12445 
12446  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
12447  SWIG_fail;
12448  }
12449  {
12450  if ( _n_dims( args(0) ) > 1 )
12451  {
12452  error( "argument must be a scalar or vector" ); SWIG_fail;
12453  }
12454  temp1 = args(0).matrix_value();
12455  arg1 = &temp1( 0, 0 );
12456  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12457  }
12458  {
12459  if ( _n_dims( args(1) ) > 1 )
12460  {
12461  error( "argument must be a scalar or vector" ); SWIG_fail;
12462  }
12463  temp2 = args(1).matrix_value();
12464  arg2 = &temp2( 0, 0 );
12465  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12466  }
12467  {
12468  if ( _n_dims( args(2) ) > 2 )
12469  {
12470  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12471  }
12472  if ( _dim( args(2), 0 ) != Xlen )
12473  {
12474  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12475  }
12476  if ( _dim( args(2), 1 ) != Ylen )
12477  {
12478  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12479  }
12480  temp3 = args(2).matrix_value();
12481  arg3 = &temp3( 0, 0 );
12482  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12483  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12484  }
12485  ecode6 = SWIG_AsVal_int(args(3), &val6);
12486  if (!SWIG_IsOK(ecode6)) {
12487  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
12488  }
12489  arg6 = (PLINT)(val6);
12490  {
12491  if ( _n_dims( args(4) ) > 1 )
12492  {
12493  error( "argument must be a scalar or vector" ); SWIG_fail;
12494  }
12495  temp7 = args(4).matrix_value();
12496  arg7 = &temp7( 0, 0 );
12497  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12498  }
12499  ecode9 = SWIG_AsVal_int(args(5), &val9);
12500  if (!SWIG_IsOK(ecode9)) {
12501  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12502  }
12503  arg9 = (PLINT)(val9);
12504  {
12505  if ( _n_dims( args(6) ) > 1 )
12506  {
12507  error( "argument must be a scalar or vector" ); SWIG_fail;
12508  }
12509  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12510  arg11 = new PLINT[Alen];
12511  temp10 = args(6).matrix_value();
12512  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12513  }
12514  {
12515  if ( _n_dims( args(7) ) > 1 )
12516  {
12517  error( "argument must be a scalar or vector" ); SWIG_fail;
12518  }
12519  if ( _dim( args(7), 0 ) != Alen )
12520  {
12521  error( "argument vectors must be same length" ); SWIG_fail;
12522  }
12523  temp12 = args(7).matrix_value();
12524  arg12 = new PLINT[Alen];
12525  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12526  }
12527  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);
12528  _outv = octave_value();
12529  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12530  {
12531 
12532  }
12533  {
12534 
12535  }
12536  {
12537 
12538  }
12539  {
12540 
12541  }
12542  {
12543  delete [] arg11;
12544  }
12545  {
12546  delete [] arg12;
12547  }
12548  return _out;
12549 fail:
12550  {
12551 
12552  }
12553  {
12554 
12555  }
12556  {
12557 
12558  }
12559  {
12560 
12561  }
12562  {
12563  delete [] arg11;
12564  }
12565  {
12566  delete [] arg12;
12567  }
12568  return octave_value_list();
12569 }
12570 
12571 
12572 SWIG_DEFUN( plshade, _wrap_plshade, _wrap_plshade_texinfo ) {
12573  PLFLT *arg1 = (PLFLT *) 0 ;
12574  PLINT arg2 ;
12575  PLINT arg3 ;
12576  PLFLT *arg4 = (PLFLT *) 0 ;
12577  PLFLT arg5 ;
12578  PLFLT arg6 ;
12579  PLFLT arg7 ;
12580  PLFLT arg8 ;
12581  PLFLT arg9 ;
12582  PLFLT arg10 ;
12583  PLINT arg11 ;
12584  PLFLT arg12 ;
12585  PLINT arg13 ;
12586  PLINT arg14 ;
12587  PLINT arg15 ;
12588  PLINT arg16 ;
12589  PLINT arg17 ;
12590  PLBOOL arg18 ;
12591  PLFLT *arg19 = (PLFLT *) 0 ;
12592  Matrix temp1 ;
12593  Matrix temp4 ;
12594  double val5 ;
12595  int ecode5 = 0 ;
12596  double val6 ;
12597  int ecode6 = 0 ;
12598  double val7 ;
12599  int ecode7 = 0 ;
12600  double val8 ;
12601  int ecode8 = 0 ;
12602  double val9 ;
12603  int ecode9 = 0 ;
12604  double val10 ;
12605  int ecode10 = 0 ;
12606  int val11 ;
12607  int ecode11 = 0 ;
12608  double val12 ;
12609  int ecode12 = 0 ;
12610  int val13 ;
12611  int ecode13 = 0 ;
12612  int val14 ;
12613  int ecode14 = 0 ;
12614  int val15 ;
12615  int ecode15 = 0 ;
12616  int val16 ;
12617  int ecode16 = 0 ;
12618  int val17 ;
12619  int ecode17 = 0 ;
12620  int val18 ;
12621  int ecode18 = 0 ;
12622  Matrix temp19 ;
12623  octave_value_list _out;
12624  octave_value_list *_outp=&_out;
12625  octave_value _outv;
12626 
12627  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12628  SWIG_fail;
12629  }
12630  {
12631  if ( _n_dims( args(0) ) > 2 )
12632  {
12633  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12634  }
12635  temp1 = args(0).matrix_value();
12636  arg1 = &temp1( 0, 0 );
12637  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12638  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12639  }
12640  {
12641  if ( _n_dims( args(1) ) > 1 )
12642  {
12643  error( "argument must be a scalar or vector" ); SWIG_fail;
12644  }
12645  Alen = (PLINT) ( _dim( args(1), 0 ) );
12646  temp4 = args(1).matrix_value();
12647  arg4 = &temp4( 0, 0 );
12648  }
12649  ecode5 = SWIG_AsVal_double(args(2), &val5);
12650  if (!SWIG_IsOK(ecode5)) {
12651  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12652  }
12653  arg5 = (PLFLT)(val5);
12654  ecode6 = SWIG_AsVal_double(args(3), &val6);
12655  if (!SWIG_IsOK(ecode6)) {
12656  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12657  }
12658  arg6 = (PLFLT)(val6);
12659  ecode7 = SWIG_AsVal_double(args(4), &val7);
12660  if (!SWIG_IsOK(ecode7)) {
12661  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12662  }
12663  arg7 = (PLFLT)(val7);
12664  ecode8 = SWIG_AsVal_double(args(5), &val8);
12665  if (!SWIG_IsOK(ecode8)) {
12666  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12667  }
12668  arg8 = (PLFLT)(val8);
12669  ecode9 = SWIG_AsVal_double(args(6), &val9);
12670  if (!SWIG_IsOK(ecode9)) {
12671  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12672  }
12673  arg9 = (PLFLT)(val9);
12674  ecode10 = SWIG_AsVal_double(args(7), &val10);
12675  if (!SWIG_IsOK(ecode10)) {
12676  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12677  }
12678  arg10 = (PLFLT)(val10);
12679  ecode11 = SWIG_AsVal_int(args(8), &val11);
12680  if (!SWIG_IsOK(ecode11)) {
12681  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12682  }
12683  arg11 = (PLINT)(val11);
12684  ecode12 = SWIG_AsVal_double(args(9), &val12);
12685  if (!SWIG_IsOK(ecode12)) {
12686  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12687  }
12688  arg12 = (PLFLT)(val12);
12689  ecode13 = SWIG_AsVal_int(args(10), &val13);
12690  if (!SWIG_IsOK(ecode13)) {
12691  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
12692  }
12693  arg13 = (PLINT)(val13);
12694  ecode14 = SWIG_AsVal_int(args(11), &val14);
12695  if (!SWIG_IsOK(ecode14)) {
12696  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12697  }
12698  arg14 = (PLINT)(val14);
12699  ecode15 = SWIG_AsVal_int(args(12), &val15);
12700  if (!SWIG_IsOK(ecode15)) {
12701  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
12702  }
12703  arg15 = (PLINT)(val15);
12704  ecode16 = SWIG_AsVal_int(args(13), &val16);
12705  if (!SWIG_IsOK(ecode16)) {
12706  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12707  }
12708  arg16 = (PLINT)(val16);
12709  ecode17 = SWIG_AsVal_int(args(14), &val17);
12710  if (!SWIG_IsOK(ecode17)) {
12711  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
12712  }
12713  arg17 = (PLINT)(val17);
12714  ecode18 = SWIG_AsVal_int(args(15), &val18);
12715  if (!SWIG_IsOK(ecode18)) {
12716  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
12717  }
12718  arg18 = (PLBOOL)(val18);
12719  {
12720  if ( _n_dims( args(16) ) > 1 )
12721  {
12722  error( "argument must be a scalar or vector" ); SWIG_fail;
12723  }
12724  if ( _dim( args(16), 0 ) != 6 )
12725  {
12726  error( "argument vectors must have length of 6" ); SWIG_fail;
12727  }
12728  temp19 = args(16).matrix_value();
12729  arg19 = &temp19( 0, 0 );
12730  }
12731  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);
12732  _outv = octave_value();
12733  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12734  {
12735 
12736  }
12737  {
12738 
12739  }
12740  {
12741 
12742  }
12743  return _out;
12744 fail:
12745  {
12746 
12747  }
12748  {
12749 
12750  }
12751  {
12752 
12753  }
12754  return octave_value_list();
12755 }
12756 
12757 
12758 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
12759  PLFLT *arg1 = (PLFLT *) 0 ;
12760  PLINT arg2 ;
12761  PLINT arg3 ;
12762  char *arg4 = (char *) 0 ;
12763  PLFLT arg5 ;
12764  PLFLT arg6 ;
12765  PLFLT arg7 ;
12766  PLFLT arg8 ;
12767  PLFLT arg9 ;
12768  PLFLT arg10 ;
12769  PLINT arg11 ;
12770  PLFLT arg12 ;
12771  PLINT arg13 ;
12772  PLINT arg14 ;
12773  PLINT arg15 ;
12774  PLINT arg16 ;
12775  PLINT arg17 ;
12776  PLBOOL arg18 ;
12777  PLFLT *arg19 = (PLFLT *) 0 ;
12778  PLFLT *arg20 = (PLFLT *) 0 ;
12779  Matrix temp1 ;
12780  int res4 ;
12781  char *buf4 = 0 ;
12782  int alloc4 = 0 ;
12783  double val5 ;
12784  int ecode5 = 0 ;
12785  double val6 ;
12786  int ecode6 = 0 ;
12787  double val7 ;
12788  int ecode7 = 0 ;
12789  double val8 ;
12790  int ecode8 = 0 ;
12791  double val9 ;
12792  int ecode9 = 0 ;
12793  double val10 ;
12794  int ecode10 = 0 ;
12795  int val11 ;
12796  int ecode11 = 0 ;
12797  double val12 ;
12798  int ecode12 = 0 ;
12799  int val13 ;
12800  int ecode13 = 0 ;
12801  int val14 ;
12802  int ecode14 = 0 ;
12803  int val15 ;
12804  int ecode15 = 0 ;
12805  int val16 ;
12806  int ecode16 = 0 ;
12807  int val17 ;
12808  int ecode17 = 0 ;
12809  int val18 ;
12810  int ecode18 = 0 ;
12811  Matrix temp19 ;
12812  Matrix temp20 ;
12813  octave_value_list _out;
12814  octave_value_list *_outp=&_out;
12815  octave_value _outv;
12816 
12817  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
12818  SWIG_fail;
12819  }
12820  {
12821  if ( _n_dims( args(0) ) > 2 )
12822  {
12823  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12824  }
12825  temp1 = args(0).matrix_value();
12826  arg1 = &temp1( 0, 0 );
12827  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12828  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12829  }
12830  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
12831  if (!SWIG_IsOK(res4)) {
12832  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
12833  }
12834  arg4 = (char *)(buf4);
12835  ecode5 = SWIG_AsVal_double(args(2), &val5);
12836  if (!SWIG_IsOK(ecode5)) {
12837  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
12838  }
12839  arg5 = (PLFLT)(val5);
12840  ecode6 = SWIG_AsVal_double(args(3), &val6);
12841  if (!SWIG_IsOK(ecode6)) {
12842  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
12843  }
12844  arg6 = (PLFLT)(val6);
12845  ecode7 = SWIG_AsVal_double(args(4), &val7);
12846  if (!SWIG_IsOK(ecode7)) {
12847  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
12848  }
12849  arg7 = (PLFLT)(val7);
12850  ecode8 = SWIG_AsVal_double(args(5), &val8);
12851  if (!SWIG_IsOK(ecode8)) {
12852  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
12853  }
12854  arg8 = (PLFLT)(val8);
12855  ecode9 = SWIG_AsVal_double(args(6), &val9);
12856  if (!SWIG_IsOK(ecode9)) {
12857  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
12858  }
12859  arg9 = (PLFLT)(val9);
12860  ecode10 = SWIG_AsVal_double(args(7), &val10);
12861  if (!SWIG_IsOK(ecode10)) {
12862  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
12863  }
12864  arg10 = (PLFLT)(val10);
12865  ecode11 = SWIG_AsVal_int(args(8), &val11);
12866  if (!SWIG_IsOK(ecode11)) {
12867  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
12868  }
12869  arg11 = (PLINT)(val11);
12870  ecode12 = SWIG_AsVal_double(args(9), &val12);
12871  if (!SWIG_IsOK(ecode12)) {
12872  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
12873  }
12874  arg12 = (PLFLT)(val12);
12875  ecode13 = SWIG_AsVal_int(args(10), &val13);
12876  if (!SWIG_IsOK(ecode13)) {
12877  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
12878  }
12879  arg13 = (PLINT)(val13);
12880  ecode14 = SWIG_AsVal_int(args(11), &val14);
12881  if (!SWIG_IsOK(ecode14)) {
12882  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
12883  }
12884  arg14 = (PLINT)(val14);
12885  ecode15 = SWIG_AsVal_int(args(12), &val15);
12886  if (!SWIG_IsOK(ecode15)) {
12887  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
12888  }
12889  arg15 = (PLINT)(val15);
12890  ecode16 = SWIG_AsVal_int(args(13), &val16);
12891  if (!SWIG_IsOK(ecode16)) {
12892  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
12893  }
12894  arg16 = (PLINT)(val16);
12895  ecode17 = SWIG_AsVal_int(args(14), &val17);
12896  if (!SWIG_IsOK(ecode17)) {
12897  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
12898  }
12899  arg17 = (PLINT)(val17);
12900  ecode18 = SWIG_AsVal_int(args(15), &val18);
12901  if (!SWIG_IsOK(ecode18)) {
12902  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
12903  }
12904  arg18 = (PLBOOL)(val18);
12905  {
12906  if ( _n_dims( args(16) ) > 1 )
12907  {
12908  error( "argument must be a scalar or vector" ); SWIG_fail;
12909  }
12910  if ( _dim( args(16), 0 ) != Xlen )
12911  {
12912  error( "argument vectors must be same length" ); SWIG_fail;
12913  }
12914  temp19 = args(16).matrix_value();
12915  arg19 = &temp19( 0, 0 );
12916  }
12917  {
12918  if ( _n_dims( args(17) ) > 1 )
12919  {
12920  error( "argument must be a scalar or vector" ); SWIG_fail;
12921  }
12922  if ( _dim( args(17), 0 ) != Ylen )
12923  {
12924  error( "argument vectors must be same length" ); SWIG_fail;
12925  }
12926  temp20 = args(17).matrix_value();
12927  arg20 = &temp20( 0, 0 );
12928  }
12929  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);
12930  _outv = octave_value();
12931  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12932  {
12933 
12934  }
12935  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12936  {
12937 
12938  }
12939  {
12940 
12941  }
12942  return _out;
12943 fail:
12944  {
12945 
12946  }
12947  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
12948  {
12949 
12950  }
12951  {
12952 
12953  }
12954  return octave_value_list();
12955 }
12956 
12957 
12958 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
12959  PLFLT *arg1 = (PLFLT *) 0 ;
12960  PLINT arg2 ;
12961  PLINT arg3 ;
12962  char *arg4 = (char *) 0 ;
12963  PLFLT arg5 ;
12964  PLFLT arg6 ;
12965  PLFLT arg7 ;
12966  PLFLT arg8 ;
12967  PLFLT arg9 ;
12968  PLFLT arg10 ;
12969  PLINT arg11 ;
12970  PLFLT arg12 ;
12971  PLINT arg13 ;
12972  PLINT arg14 ;
12973  PLINT arg15 ;
12974  PLINT arg16 ;
12975  PLINT arg17 ;
12976  PLBOOL arg18 ;
12977  PLFLT *arg19 = (PLFLT *) 0 ;
12978  PLFLT *arg20 = (PLFLT *) 0 ;
12979  Matrix temp1 ;
12980  int res4 ;
12981  char *buf4 = 0 ;
12982  int alloc4 = 0 ;
12983  double val5 ;
12984  int ecode5 = 0 ;
12985  double val6 ;
12986  int ecode6 = 0 ;
12987  double val7 ;
12988  int ecode7 = 0 ;
12989  double val8 ;
12990  int ecode8 = 0 ;
12991  double val9 ;
12992  int ecode9 = 0 ;
12993  double val10 ;
12994  int ecode10 = 0 ;
12995  int val11 ;
12996  int ecode11 = 0 ;
12997  double val12 ;
12998  int ecode12 = 0 ;
12999  int val13 ;
13000  int ecode13 = 0 ;
13001  int val14 ;
13002  int ecode14 = 0 ;
13003  int val15 ;
13004  int ecode15 = 0 ;
13005  int val16 ;
13006  int ecode16 = 0 ;
13007  int val17 ;
13008  int ecode17 = 0 ;
13009  int val18 ;
13010  int ecode18 = 0 ;
13011  Matrix temp19 ;
13012  Matrix temp20 ;
13013  octave_value_list _out;
13014  octave_value_list *_outp=&_out;
13015  octave_value _outv;
13016 
13017  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13018  SWIG_fail;
13019  }
13020  {
13021  if ( _n_dims( args(0) ) > 2 )
13022  {
13023  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13024  }
13025  temp1 = args(0).matrix_value();
13026  arg1 = &temp1( 0, 0 );
13027  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13028  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13029  }
13030  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13031  if (!SWIG_IsOK(res4)) {
13032  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13033  }
13034  arg4 = (char *)(buf4);
13035  ecode5 = SWIG_AsVal_double(args(2), &val5);
13036  if (!SWIG_IsOK(ecode5)) {
13037  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13038  }
13039  arg5 = (PLFLT)(val5);
13040  ecode6 = SWIG_AsVal_double(args(3), &val6);
13041  if (!SWIG_IsOK(ecode6)) {
13042  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13043  }
13044  arg6 = (PLFLT)(val6);
13045  ecode7 = SWIG_AsVal_double(args(4), &val7);
13046  if (!SWIG_IsOK(ecode7)) {
13047  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13048  }
13049  arg7 = (PLFLT)(val7);
13050  ecode8 = SWIG_AsVal_double(args(5), &val8);
13051  if (!SWIG_IsOK(ecode8)) {
13052  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13053  }
13054  arg8 = (PLFLT)(val8);
13055  ecode9 = SWIG_AsVal_double(args(6), &val9);
13056  if (!SWIG_IsOK(ecode9)) {
13057  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13058  }
13059  arg9 = (PLFLT)(val9);
13060  ecode10 = SWIG_AsVal_double(args(7), &val10);
13061  if (!SWIG_IsOK(ecode10)) {
13062  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13063  }
13064  arg10 = (PLFLT)(val10);
13065  ecode11 = SWIG_AsVal_int(args(8), &val11);
13066  if (!SWIG_IsOK(ecode11)) {
13067  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13068  }
13069  arg11 = (PLINT)(val11);
13070  ecode12 = SWIG_AsVal_double(args(9), &val12);
13071  if (!SWIG_IsOK(ecode12)) {
13072  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13073  }
13074  arg12 = (PLFLT)(val12);
13075  ecode13 = SWIG_AsVal_int(args(10), &val13);
13076  if (!SWIG_IsOK(ecode13)) {
13077  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13078  }
13079  arg13 = (PLINT)(val13);
13080  ecode14 = SWIG_AsVal_int(args(11), &val14);
13081  if (!SWIG_IsOK(ecode14)) {
13082  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13083  }
13084  arg14 = (PLINT)(val14);
13085  ecode15 = SWIG_AsVal_int(args(12), &val15);
13086  if (!SWIG_IsOK(ecode15)) {
13087  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13088  }
13089  arg15 = (PLINT)(val15);
13090  ecode16 = SWIG_AsVal_int(args(13), &val16);
13091  if (!SWIG_IsOK(ecode16)) {
13092  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13093  }
13094  arg16 = (PLINT)(val16);
13095  ecode17 = SWIG_AsVal_int(args(14), &val17);
13096  if (!SWIG_IsOK(ecode17)) {
13097  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13098  }
13099  arg17 = (PLINT)(val17);
13100  ecode18 = SWIG_AsVal_int(args(15), &val18);
13101  if (!SWIG_IsOK(ecode18)) {
13102  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13103  }
13104  arg18 = (PLBOOL)(val18);
13105  {
13106  if ( _n_dims( args(16) ) > 2 )
13107  {
13108  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13109  }
13110  temp19 = args(16).matrix_value();
13111  arg19 = &temp19( 0, 0 );
13112  Xlen = (PLINT) ( _dim( args(16), 0 ) );
13113  Ylen = (PLINT) ( _dim( args(16), 1 ) );
13114  }
13115  {
13116  if ( _n_dims( args(17) ) > 2 )
13117  {
13118  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13119  }
13120  temp20 = args(17).matrix_value();
13121  arg20 = &temp20( 0, 0 );
13122  Xlen = (PLINT) ( _dim( args(17), 0 ) );
13123  Ylen = (PLINT) ( _dim( args(17), 1 ) );
13124  }
13125  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);
13126  _outv = octave_value();
13127  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13128  {
13129 
13130  }
13131  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13132  {
13133 
13134  }
13135  {
13136 
13137  }
13138  return _out;
13139 fail:
13140  {
13141 
13142  }
13143  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13144  {
13145 
13146  }
13147  {
13148 
13149  }
13150  return octave_value_list();
13151 }
13152 
13153 
13154 SWIG_DEFUN( plshades, _wrap_plshades, _wrap_plshades_texinfo ) {
13155  PLFLT *arg1 = (PLFLT *) 0 ;
13156  PLINT arg2 ;
13157  PLINT arg3 ;
13158  PLFLT arg4 ;
13159  PLFLT arg5 ;
13160  PLFLT arg6 ;
13161  PLFLT arg7 ;
13162  PLFLT *arg8 = (PLFLT *) 0 ;
13163  PLINT arg9 ;
13164  PLINT arg10 ;
13165  PLINT arg11 ;
13166  PLINT arg12 ;
13167  PLBOOL arg13 ;
13168  Matrix temp1 ;
13169  double val4 ;
13170  int ecode4 = 0 ;
13171  double val5 ;
13172  int ecode5 = 0 ;
13173  double val6 ;
13174  int ecode6 = 0 ;
13175  double val7 ;
13176  int ecode7 = 0 ;
13177  Matrix temp8 ;
13178  int val10 ;
13179  int ecode10 = 0 ;
13180  int val11 ;
13181  int ecode11 = 0 ;
13182  int val12 ;
13183  int ecode12 = 0 ;
13184  int val13 ;
13185  int ecode13 = 0 ;
13186  octave_value_list _out;
13187  octave_value_list *_outp=&_out;
13188  octave_value _outv;
13189 
13190  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13191  SWIG_fail;
13192  }
13193  {
13194  if ( _n_dims( args(0) ) > 2 )
13195  {
13196  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13197  }
13198  temp1 = args(0).matrix_value();
13199  arg1 = &temp1( 0, 0 );
13200  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13201  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13202  }
13203  ecode4 = SWIG_AsVal_double(args(1), &val4);
13204  if (!SWIG_IsOK(ecode4)) {
13205  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13206  }
13207  arg4 = (PLFLT)(val4);
13208  ecode5 = SWIG_AsVal_double(args(2), &val5);
13209  if (!SWIG_IsOK(ecode5)) {
13210  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13211  }
13212  arg5 = (PLFLT)(val5);
13213  ecode6 = SWIG_AsVal_double(args(3), &val6);
13214  if (!SWIG_IsOK(ecode6)) {
13215  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13216  }
13217  arg6 = (PLFLT)(val6);
13218  ecode7 = SWIG_AsVal_double(args(4), &val7);
13219  if (!SWIG_IsOK(ecode7)) {
13220  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13221  }
13222  arg7 = (PLFLT)(val7);
13223  {
13224  if ( _n_dims( args(5) ) > 1 )
13225  {
13226  error( "argument must be a scalar or vector" ); SWIG_fail;
13227  }
13228  temp8 = args(5).matrix_value();
13229  arg8 = &temp8( 0, 0 );
13230  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13231  }
13232  ecode10 = SWIG_AsVal_int(args(6), &val10);
13233  if (!SWIG_IsOK(ecode10)) {
13234  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13235  }
13236  arg10 = (PLINT)(val10);
13237  ecode11 = SWIG_AsVal_int(args(7), &val11);
13238  if (!SWIG_IsOK(ecode11)) {
13239  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13240  }
13241  arg11 = (PLINT)(val11);
13242  ecode12 = SWIG_AsVal_int(args(8), &val12);
13243  if (!SWIG_IsOK(ecode12)) {
13244  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13245  }
13246  arg12 = (PLINT)(val12);
13247  ecode13 = SWIG_AsVal_int(args(9), &val13);
13248  if (!SWIG_IsOK(ecode13)) {
13249  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13250  }
13251  arg13 = (PLBOOL)(val13);
13252  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13253  _outv = octave_value();
13254  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13255  {
13256 
13257  }
13258  {
13259 
13260  }
13261  return _out;
13262 fail:
13263  {
13264 
13265  }
13266  {
13267 
13268  }
13269  return octave_value_list();
13270 }
13271 
13272 
13273 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
13274  PLFLT *arg1 = (PLFLT *) 0 ;
13275  PLINT arg2 ;
13276  PLINT arg3 ;
13277  PLFLT arg4 ;
13278  PLFLT arg5 ;
13279  PLFLT arg6 ;
13280  PLFLT arg7 ;
13281  PLFLT *arg8 = (PLFLT *) 0 ;
13282  PLINT arg9 ;
13283  PLINT arg10 ;
13284  PLINT arg11 ;
13285  PLINT arg12 ;
13286  PLBOOL arg13 ;
13287  PLFLT *arg14 = (PLFLT *) 0 ;
13288  Matrix temp1 ;
13289  double val4 ;
13290  int ecode4 = 0 ;
13291  double val5 ;
13292  int ecode5 = 0 ;
13293  double val6 ;
13294  int ecode6 = 0 ;
13295  double val7 ;
13296  int ecode7 = 0 ;
13297  Matrix temp8 ;
13298  int val10 ;
13299  int ecode10 = 0 ;
13300  int val11 ;
13301  int ecode11 = 0 ;
13302  int val12 ;
13303  int ecode12 = 0 ;
13304  int val13 ;
13305  int ecode13 = 0 ;
13306  Matrix temp14 ;
13307  octave_value_list _out;
13308  octave_value_list *_outp=&_out;
13309  octave_value _outv;
13310 
13311  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
13312  SWIG_fail;
13313  }
13314  {
13315  if ( _n_dims( args(0) ) > 2 )
13316  {
13317  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13318  }
13319  temp1 = args(0).matrix_value();
13320  arg1 = &temp1( 0, 0 );
13321  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13322  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13323  }
13324  ecode4 = SWIG_AsVal_double(args(1), &val4);
13325  if (!SWIG_IsOK(ecode4)) {
13326  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
13327  }
13328  arg4 = (PLFLT)(val4);
13329  ecode5 = SWIG_AsVal_double(args(2), &val5);
13330  if (!SWIG_IsOK(ecode5)) {
13331  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
13332  }
13333  arg5 = (PLFLT)(val5);
13334  ecode6 = SWIG_AsVal_double(args(3), &val6);
13335  if (!SWIG_IsOK(ecode6)) {
13336  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
13337  }
13338  arg6 = (PLFLT)(val6);
13339  ecode7 = SWIG_AsVal_double(args(4), &val7);
13340  if (!SWIG_IsOK(ecode7)) {
13341  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
13342  }
13343  arg7 = (PLFLT)(val7);
13344  {
13345  if ( _n_dims( args(5) ) > 1 )
13346  {
13347  error( "argument must be a scalar or vector" ); SWIG_fail;
13348  }
13349  temp8 = args(5).matrix_value();
13350  arg8 = &temp8( 0, 0 );
13351  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13352  }
13353  ecode10 = SWIG_AsVal_int(args(6), &val10);
13354  if (!SWIG_IsOK(ecode10)) {
13355  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
13356  }
13357  arg10 = (PLINT)(val10);
13358  ecode11 = SWIG_AsVal_int(args(7), &val11);
13359  if (!SWIG_IsOK(ecode11)) {
13360  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
13361  }
13362  arg11 = (PLINT)(val11);
13363  ecode12 = SWIG_AsVal_int(args(8), &val12);
13364  if (!SWIG_IsOK(ecode12)) {
13365  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
13366  }
13367  arg12 = (PLINT)(val12);
13368  ecode13 = SWIG_AsVal_int(args(9), &val13);
13369  if (!SWIG_IsOK(ecode13)) {
13370  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
13371  }
13372  arg13 = (PLBOOL)(val13);
13373  {
13374  if ( _n_dims( args(10) ) > 1 )
13375  {
13376  error( "argument must be a scalar or vector" ); SWIG_fail;
13377  }
13378  if ( _dim( args(10), 0 ) != 6 )
13379  {
13380  error( "argument vectors must have length of 6" ); SWIG_fail;
13381  }
13382  temp14 = args(10).matrix_value();
13383  arg14 = &temp14( 0, 0 );
13384  }
13385  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13386  _outv = octave_value();
13387  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13388  {
13389 
13390  }
13391  {
13392 
13393  }
13394  {
13395 
13396  }
13397  return _out;
13398 fail:
13399  {
13400 
13401  }
13402  {
13403 
13404  }
13405  {
13406 
13407  }
13408  return octave_value_list();
13409 }
13410 
13411 
13412 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
13413  PLFLT *arg1 = (PLFLT *) 0 ;
13414  PLINT arg2 ;
13415  PLINT arg3 ;
13416  PLFLT arg4 ;
13417  PLFLT arg5 ;
13418  PLFLT arg6 ;
13419  PLFLT arg7 ;
13420  PLFLT *arg8 = (PLFLT *) 0 ;
13421  PLINT arg9 ;
13422  PLINT arg10 ;
13423  PLINT arg11 ;
13424  PLINT arg12 ;
13425  PLBOOL arg13 ;
13426  PLFLT *arg14 = (PLFLT *) 0 ;
13427  PLFLT *arg15 = (PLFLT *) 0 ;
13428  Matrix temp1 ;
13429  double val4 ;
13430  int ecode4 = 0 ;
13431  double val5 ;
13432  int ecode5 = 0 ;
13433  double val6 ;
13434  int ecode6 = 0 ;
13435  double val7 ;
13436  int ecode7 = 0 ;
13437  Matrix temp8 ;
13438  int val10 ;
13439  int ecode10 = 0 ;
13440  int val11 ;
13441  int ecode11 = 0 ;
13442  int val12 ;
13443  int ecode12 = 0 ;
13444  int val13 ;
13445  int ecode13 = 0 ;
13446  Matrix temp14 ;
13447  Matrix temp15 ;
13448  octave_value_list _out;
13449  octave_value_list *_outp=&_out;
13450  octave_value _outv;
13451 
13452  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
13453  SWIG_fail;
13454  }
13455  {
13456  if ( _n_dims( args(0) ) > 2 )
13457  {
13458  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13459  }
13460  temp1 = args(0).matrix_value();
13461  arg1 = &temp1( 0, 0 );
13462  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13463  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13464  }
13465  ecode4 = SWIG_AsVal_double(args(1), &val4);
13466  if (!SWIG_IsOK(ecode4)) {
13467  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
13468  }
13469  arg4 = (PLFLT)(val4);
13470  ecode5 = SWIG_AsVal_double(args(2), &val5);
13471  if (!SWIG_IsOK(ecode5)) {
13472  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
13473  }
13474  arg5 = (PLFLT)(val5);
13475  ecode6 = SWIG_AsVal_double(args(3), &val6);
13476  if (!SWIG_IsOK(ecode6)) {
13477  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
13478  }
13479  arg6 = (PLFLT)(val6);
13480  ecode7 = SWIG_AsVal_double(args(4), &val7);
13481  if (!SWIG_IsOK(ecode7)) {
13482  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
13483  }
13484  arg7 = (PLFLT)(val7);
13485  {
13486  if ( _n_dims( args(5) ) > 1 )
13487  {
13488  error( "argument must be a scalar or vector" ); SWIG_fail;
13489  }
13490  temp8 = args(5).matrix_value();
13491  arg8 = &temp8( 0, 0 );
13492  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13493  }
13494  ecode10 = SWIG_AsVal_int(args(6), &val10);
13495  if (!SWIG_IsOK(ecode10)) {
13496  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
13497  }
13498  arg10 = (PLINT)(val10);
13499  ecode11 = SWIG_AsVal_int(args(7), &val11);
13500  if (!SWIG_IsOK(ecode11)) {
13501  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
13502  }
13503  arg11 = (PLINT)(val11);
13504  ecode12 = SWIG_AsVal_int(args(8), &val12);
13505  if (!SWIG_IsOK(ecode12)) {
13506  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
13507  }
13508  arg12 = (PLINT)(val12);
13509  ecode13 = SWIG_AsVal_int(args(9), &val13);
13510  if (!SWIG_IsOK(ecode13)) {
13511  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
13512  }
13513  arg13 = (PLBOOL)(val13);
13514  {
13515  if ( _n_dims( args(10) ) > 1 )
13516  {
13517  error( "argument must be a scalar or vector" ); SWIG_fail;
13518  }
13519  if ( _dim( args(10), 0 ) != Xlen )
13520  {
13521  error( "argument vectors must be same length" ); SWIG_fail;
13522  }
13523  temp14 = args(10).matrix_value();
13524  arg14 = &temp14( 0, 0 );
13525  }
13526  {
13527  if ( _n_dims( args(11) ) > 1 )
13528  {
13529  error( "argument must be a scalar or vector" ); SWIG_fail;
13530  }
13531  if ( _dim( args(11), 0 ) != Ylen )
13532  {
13533  error( "argument vectors must be same length" ); SWIG_fail;
13534  }
13535  temp15 = args(11).matrix_value();
13536  arg15 = &temp15( 0, 0 );
13537  }
13538  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);
13539  _outv = octave_value();
13540  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13541  {
13542 
13543  }
13544  {
13545 
13546  }
13547  {
13548 
13549  }
13550  {
13551 
13552  }
13553  return _out;
13554 fail:
13555  {
13556 
13557  }
13558  {
13559 
13560  }
13561  {
13562 
13563  }
13564  {
13565 
13566  }
13567  return octave_value_list();
13568 }
13569 
13570 
13571 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
13572  PLFLT *arg1 = (PLFLT *) 0 ;
13573  PLINT arg2 ;
13574  PLINT arg3 ;
13575  PLFLT arg4 ;
13576  PLFLT arg5 ;
13577  PLFLT arg6 ;
13578  PLFLT arg7 ;
13579  PLFLT *arg8 = (PLFLT *) 0 ;
13580  PLINT arg9 ;
13581  PLINT arg10 ;
13582  PLINT arg11 ;
13583  PLINT arg12 ;
13584  PLBOOL arg13 ;
13585  PLFLT *arg14 = (PLFLT *) 0 ;
13586  PLFLT *arg15 = (PLFLT *) 0 ;
13587  Matrix temp1 ;
13588  double val4 ;
13589  int ecode4 = 0 ;
13590  double val5 ;
13591  int ecode5 = 0 ;
13592  double val6 ;
13593  int ecode6 = 0 ;
13594  double val7 ;
13595  int ecode7 = 0 ;
13596  Matrix temp8 ;
13597  int val10 ;
13598  int ecode10 = 0 ;
13599  int val11 ;
13600  int ecode11 = 0 ;
13601  int val12 ;
13602  int ecode12 = 0 ;
13603  int val13 ;
13604  int ecode13 = 0 ;
13605  Matrix temp14 ;
13606  Matrix temp15 ;
13607  octave_value_list _out;
13608  octave_value_list *_outp=&_out;
13609  octave_value _outv;
13610 
13611  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13612  SWIG_fail;
13613  }
13614  {
13615  if ( _n_dims( args(0) ) > 2 )
13616  {
13617  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13618  }
13619  temp1 = args(0).matrix_value();
13620  arg1 = &temp1( 0, 0 );
13621  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13622  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13623  }
13624  ecode4 = SWIG_AsVal_double(args(1), &val4);
13625  if (!SWIG_IsOK(ecode4)) {
13626  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13627  }
13628  arg4 = (PLFLT)(val4);
13629  ecode5 = SWIG_AsVal_double(args(2), &val5);
13630  if (!SWIG_IsOK(ecode5)) {
13631  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13632  }
13633  arg5 = (PLFLT)(val5);
13634  ecode6 = SWIG_AsVal_double(args(3), &val6);
13635  if (!SWIG_IsOK(ecode6)) {
13636  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13637  }
13638  arg6 = (PLFLT)(val6);
13639  ecode7 = SWIG_AsVal_double(args(4), &val7);
13640  if (!SWIG_IsOK(ecode7)) {
13641  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13642  }
13643  arg7 = (PLFLT)(val7);
13644  {
13645  if ( _n_dims( args(5) ) > 1 )
13646  {
13647  error( "argument must be a scalar or vector" ); SWIG_fail;
13648  }
13649  temp8 = args(5).matrix_value();
13650  arg8 = &temp8( 0, 0 );
13651  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13652  }
13653  ecode10 = SWIG_AsVal_int(args(6), &val10);
13654  if (!SWIG_IsOK(ecode10)) {
13655  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13656  }
13657  arg10 = (PLINT)(val10);
13658  ecode11 = SWIG_AsVal_int(args(7), &val11);
13659  if (!SWIG_IsOK(ecode11)) {
13660  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13661  }
13662  arg11 = (PLINT)(val11);
13663  ecode12 = SWIG_AsVal_int(args(8), &val12);
13664  if (!SWIG_IsOK(ecode12)) {
13665  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13666  }
13667  arg12 = (PLINT)(val12);
13668  ecode13 = SWIG_AsVal_int(args(9), &val13);
13669  if (!SWIG_IsOK(ecode13)) {
13670  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13671  }
13672  arg13 = (PLBOOL)(val13);
13673  {
13674  if ( _n_dims( args(10) ) > 2 )
13675  {
13676  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13677  }
13678  temp14 = args(10).matrix_value();
13679  arg14 = &temp14( 0, 0 );
13680  Xlen = (PLINT) ( _dim( args(10), 0 ) );
13681  Ylen = (PLINT) ( _dim( args(10), 1 ) );
13682  }
13683  {
13684  if ( _n_dims( args(11) ) > 2 )
13685  {
13686  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13687  }
13688  temp15 = args(11).matrix_value();
13689  arg15 = &temp15( 0, 0 );
13690  Xlen = (PLINT) ( _dim( args(11), 0 ) );
13691  Ylen = (PLINT) ( _dim( args(11), 1 ) );
13692  }
13693  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);
13694  _outv = octave_value();
13695  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13696  {
13697 
13698  }
13699  {
13700 
13701  }
13702  {
13703 
13704  }
13705  {
13706 
13707  }
13708  return _out;
13709 fail:
13710  {
13711 
13712  }
13713  {
13714 
13715  }
13716  {
13717 
13718  }
13719  {
13720 
13721  }
13722  return octave_value_list();
13723 }
13724 
13725 
13726 SWIG_DEFUN( plvect, _wrap_plvect, _wrap_plvect_texinfo ) {
13727  PLFLT *arg1 = (PLFLT *) 0 ;
13728  PLFLT *arg2 = (PLFLT *) 0 ;
13729  PLINT arg3 ;
13730  PLINT arg4 ;
13731  PLFLT arg5 ;
13732  PLFLT *arg6 = (PLFLT *) 0 ;
13733  Matrix temp1 ;
13734  Matrix temp2 ;
13735  double val5 ;
13736  int ecode5 = 0 ;
13737  Matrix temp6 ;
13738  octave_value_list _out;
13739  octave_value_list *_outp=&_out;
13740  octave_value _outv;
13741 
13742  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
13743  SWIG_fail;
13744  }
13745  {
13746  if ( _n_dims( args(0) ) > 2 )
13747  {
13748  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13749  }
13750  temp1 = args(0).matrix_value();
13751  arg1 = &temp1( 0, 0 );
13752  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13753  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13754  }
13755  {
13756  if ( _n_dims( args(1) ) > 2 )
13757  {
13758  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13759  }
13760  if ( _dim( args(1), 0 ) != Xlen )
13761  {
13762  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13763  }
13764  if ( _dim( args(1), 1 ) != Ylen )
13765  {
13766  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13767  }
13768  temp2 = args(1).matrix_value();
13769  arg2 = &temp2( 0, 0 );
13770  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13771  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13772  }
13773  ecode5 = SWIG_AsVal_double(args(2), &val5);
13774  if (!SWIG_IsOK(ecode5)) {
13775  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13776  }
13777  arg5 = (PLFLT)(val5);
13778  {
13779  if ( _n_dims( args(3) ) > 1 )
13780  {
13781  error( "argument must be a scalar or vector" ); SWIG_fail;
13782  }
13783  if ( _dim( args(3), 0 ) != 6 )
13784  {
13785  error( "argument vectors must have length of 6" ); SWIG_fail;
13786  }
13787  temp6 = args(3).matrix_value();
13788  arg6 = &temp6( 0, 0 );
13789  }
13790  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
13791  _outv = octave_value();
13792  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13793  {
13794 
13795  }
13796  {
13797 
13798  }
13799  {
13800 
13801  }
13802  return _out;
13803 fail:
13804  {
13805 
13806  }
13807  {
13808 
13809  }
13810  {
13811 
13812  }
13813  return octave_value_list();
13814 }
13815 
13816 
13817 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
13818  PLFLT *arg1 = (PLFLT *) 0 ;
13819  PLFLT *arg2 = (PLFLT *) 0 ;
13820  PLINT arg3 ;
13821  PLINT arg4 ;
13822  PLFLT arg5 ;
13823  PLFLT *arg6 = (PLFLT *) 0 ;
13824  PLFLT *arg7 = (PLFLT *) 0 ;
13825  Matrix temp1 ;
13826  Matrix temp2 ;
13827  double val5 ;
13828  int ecode5 = 0 ;
13829  Matrix temp6 ;
13830  Matrix temp7 ;
13831  octave_value_list _out;
13832  octave_value_list *_outp=&_out;
13833  octave_value _outv;
13834 
13835  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
13836  SWIG_fail;
13837  }
13838  {
13839  if ( _n_dims( args(0) ) > 2 )
13840  {
13841  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13842  }
13843  temp1 = args(0).matrix_value();
13844  arg1 = &temp1( 0, 0 );
13845  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13846  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13847  }
13848  {
13849  if ( _n_dims( args(1) ) > 2 )
13850  {
13851  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13852  }
13853  if ( _dim( args(1), 0 ) != Xlen )
13854  {
13855  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13856  }
13857  if ( _dim( args(1), 1 ) != Ylen )
13858  {
13859  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13860  }
13861  temp2 = args(1).matrix_value();
13862  arg2 = &temp2( 0, 0 );
13863  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13864  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13865  }
13866  ecode5 = SWIG_AsVal_double(args(2), &val5);
13867  if (!SWIG_IsOK(ecode5)) {
13868  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
13869  }
13870  arg5 = (PLFLT)(val5);
13871  {
13872  if ( _n_dims( args(3) ) > 1 )
13873  {
13874  error( "argument must be a scalar or vector" ); SWIG_fail;
13875  }
13876  if ( _dim( args(3), 0 ) != Xlen )
13877  {
13878  error( "argument vectors must be same length" ); SWIG_fail;
13879  }
13880  temp6 = args(3).matrix_value();
13881  arg6 = &temp6( 0, 0 );
13882  }
13883  {
13884  if ( _n_dims( args(4) ) > 1 )
13885  {
13886  error( "argument must be a scalar or vector" ); SWIG_fail;
13887  }
13888  if ( _dim( args(4), 0 ) != Ylen )
13889  {
13890  error( "argument vectors must be same length" ); SWIG_fail;
13891  }
13892  temp7 = args(4).matrix_value();
13893  arg7 = &temp7( 0, 0 );
13894  }
13895  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
13896  _outv = octave_value();
13897  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13898  {
13899 
13900  }
13901  {
13902 
13903  }
13904  {
13905 
13906  }
13907  {
13908 
13909  }
13910  return _out;
13911 fail:
13912  {
13913 
13914  }
13915  {
13916 
13917  }
13918  {
13919 
13920  }
13921  {
13922 
13923  }
13924  return octave_value_list();
13925 }
13926 
13927 
13928 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
13929  PLFLT *arg1 = (PLFLT *) 0 ;
13930  PLFLT *arg2 = (PLFLT *) 0 ;
13931  PLINT arg3 ;
13932  PLINT arg4 ;
13933  PLFLT arg5 ;
13934  PLFLT *arg6 = (PLFLT *) 0 ;
13935  PLFLT *arg7 = (PLFLT *) 0 ;
13936  Matrix temp1 ;
13937  Matrix temp2 ;
13938  double val5 ;
13939  int ecode5 = 0 ;
13940  Matrix temp6 ;
13941  Matrix temp7 ;
13942  octave_value_list _out;
13943  octave_value_list *_outp=&_out;
13944  octave_value _outv;
13945 
13946  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
13947  SWIG_fail;
13948  }
13949  {
13950  if ( _n_dims( args(0) ) > 2 )
13951  {
13952  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13953  }
13954  temp1 = args(0).matrix_value();
13955  arg1 = &temp1( 0, 0 );
13956  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13957  Ylen = (PLINT) ( _dim( args(0), 1 ) );
13958  }
13959  {
13960  if ( _n_dims( args(1) ) > 2 )
13961  {
13962  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13963  }
13964  if ( _dim( args(1), 0 ) != Xlen )
13965  {
13966  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13967  }
13968  if ( _dim( args(1), 1 ) != Ylen )
13969  {
13970  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13971  }
13972  temp2 = args(1).matrix_value();
13973  arg2 = &temp2( 0, 0 );
13974  arg3 = (PLINT) ( _dim( args(1), 0 ) );
13975  arg4 = (PLINT) ( _dim( args(1), 1 ) );
13976  }
13977  ecode5 = SWIG_AsVal_double(args(2), &val5);
13978  if (!SWIG_IsOK(ecode5)) {
13979  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
13980  }
13981  arg5 = (PLFLT)(val5);
13982  {
13983  if ( _n_dims( args(3) ) > 2 )
13984  {
13985  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13986  }
13987  temp6 = args(3).matrix_value();
13988  arg6 = &temp6( 0, 0 );
13989  Xlen = (PLINT) ( _dim( args(3), 0 ) );
13990  Ylen = (PLINT) ( _dim( args(3), 1 ) );
13991  }
13992  {
13993  if ( _n_dims( args(4) ) > 2 )
13994  {
13995  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13996  }
13997  temp7 = args(4).matrix_value();
13998  arg7 = &temp7( 0, 0 );
13999  Xlen = (PLINT) ( _dim( args(4), 0 ) );
14000  Ylen = (PLINT) ( _dim( args(4), 1 ) );
14001  }
14002  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14003  _outv = octave_value();
14004  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14005  {
14006 
14007  }
14008  {
14009 
14010  }
14011  {
14012 
14013  }
14014  {
14015 
14016  }
14017  return _out;
14018 fail:
14019  {
14020 
14021  }
14022  {
14023 
14024  }
14025  {
14026 
14027  }
14028  {
14029 
14030  }
14031  return octave_value_list();
14032 }
14033 
14034 
14035 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14036  PLFLT *arg1 = (PLFLT *) 0 ;
14037  PLINT arg2 ;
14038  PLINT arg3 ;
14039  PLFLT arg4 ;
14040  PLFLT arg5 ;
14041  PLFLT arg6 ;
14042  PLFLT arg7 ;
14043  PLFLT arg8 ;
14044  PLFLT arg9 ;
14045  PLFLT arg10 ;
14046  PLFLT arg11 ;
14047  PLFLT arg12 ;
14048  PLFLT arg13 ;
14049  Matrix temp1 ;
14050  double val4 ;
14051  int ecode4 = 0 ;
14052  double val5 ;
14053  int ecode5 = 0 ;
14054  double val6 ;
14055  int ecode6 = 0 ;
14056  double val7 ;
14057  int ecode7 = 0 ;
14058  double val8 ;
14059  int ecode8 = 0 ;
14060  double val9 ;
14061  int ecode9 = 0 ;
14062  double val10 ;
14063  int ecode10 = 0 ;
14064  double val11 ;
14065  int ecode11 = 0 ;
14066  double val12 ;
14067  int ecode12 = 0 ;
14068  double val13 ;
14069  int ecode13 = 0 ;
14070  octave_value_list _out;
14071  octave_value_list *_outp=&_out;
14072  octave_value _outv;
14073 
14074  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14075  SWIG_fail;
14076  }
14077  {
14078  if ( _n_dims( args(0) ) > 2 )
14079  {
14080  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14081  }
14082  temp1 = args(0).matrix_value();
14083  arg1 = &temp1( 0, 0 );
14084  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14085  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14086  }
14087  ecode4 = SWIG_AsVal_double(args(1), &val4);
14088  if (!SWIG_IsOK(ecode4)) {
14089  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14090  }
14091  arg4 = (PLFLT)(val4);
14092  ecode5 = SWIG_AsVal_double(args(2), &val5);
14093  if (!SWIG_IsOK(ecode5)) {
14094  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14095  }
14096  arg5 = (PLFLT)(val5);
14097  ecode6 = SWIG_AsVal_double(args(3), &val6);
14098  if (!SWIG_IsOK(ecode6)) {
14099  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14100  }
14101  arg6 = (PLFLT)(val6);
14102  ecode7 = SWIG_AsVal_double(args(4), &val7);
14103  if (!SWIG_IsOK(ecode7)) {
14104  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14105  }
14106  arg7 = (PLFLT)(val7);
14107  ecode8 = SWIG_AsVal_double(args(5), &val8);
14108  if (!SWIG_IsOK(ecode8)) {
14109  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14110  }
14111  arg8 = (PLFLT)(val8);
14112  ecode9 = SWIG_AsVal_double(args(6), &val9);
14113  if (!SWIG_IsOK(ecode9)) {
14114  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14115  }
14116  arg9 = (PLFLT)(val9);
14117  ecode10 = SWIG_AsVal_double(args(7), &val10);
14118  if (!SWIG_IsOK(ecode10)) {
14119  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14120  }
14121  arg10 = (PLFLT)(val10);
14122  ecode11 = SWIG_AsVal_double(args(8), &val11);
14123  if (!SWIG_IsOK(ecode11)) {
14124  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14125  }
14126  arg11 = (PLFLT)(val11);
14127  ecode12 = SWIG_AsVal_double(args(9), &val12);
14128  if (!SWIG_IsOK(ecode12)) {
14129  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14130  }
14131  arg12 = (PLFLT)(val12);
14132  ecode13 = SWIG_AsVal_double(args(10), &val13);
14133  if (!SWIG_IsOK(ecode13)) {
14134  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14135  }
14136  arg13 = (PLFLT)(val13);
14137  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14138  _outv = octave_value();
14139  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14140  {
14141 
14142  }
14143  return _out;
14144 fail:
14145  {
14146 
14147  }
14148  return octave_value_list();
14149 }
14150 
14151 
14152 SWIG_DEFUN( plimagefr, _wrap_plimagefr, _wrap_plimagefr_texinfo ) {
14153  PLFLT *arg1 = (PLFLT *) 0 ;
14154  PLINT arg2 ;
14155  PLINT arg3 ;
14156  PLFLT arg4 ;
14157  PLFLT arg5 ;
14158  PLFLT arg6 ;
14159  PLFLT arg7 ;
14160  PLFLT arg8 ;
14161  PLFLT arg9 ;
14162  PLFLT arg10 ;
14163  PLFLT arg11 ;
14164  Matrix temp1 ;
14165  double val4 ;
14166  int ecode4 = 0 ;
14167  double val5 ;
14168  int ecode5 = 0 ;
14169  double val6 ;
14170  int ecode6 = 0 ;
14171  double val7 ;
14172  int ecode7 = 0 ;
14173  double val8 ;
14174  int ecode8 = 0 ;
14175  double val9 ;
14176  int ecode9 = 0 ;
14177  double val10 ;
14178  int ecode10 = 0 ;
14179  double val11 ;
14180  int ecode11 = 0 ;
14181  octave_value_list _out;
14182  octave_value_list *_outp=&_out;
14183  octave_value _outv;
14184 
14185  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
14186  SWIG_fail;
14187  }
14188  {
14189  if ( _n_dims( args(0) ) > 2 )
14190  {
14191  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14192  }
14193  temp1 = args(0).matrix_value();
14194  arg1 = &temp1( 0, 0 );
14195  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14196  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14197  }
14198  ecode4 = SWIG_AsVal_double(args(1), &val4);
14199  if (!SWIG_IsOK(ecode4)) {
14200  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14201  }
14202  arg4 = (PLFLT)(val4);
14203  ecode5 = SWIG_AsVal_double(args(2), &val5);
14204  if (!SWIG_IsOK(ecode5)) {
14205  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14206  }
14207  arg5 = (PLFLT)(val5);
14208  ecode6 = SWIG_AsVal_double(args(3), &val6);
14209  if (!SWIG_IsOK(ecode6)) {
14210  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14211  }
14212  arg6 = (PLFLT)(val6);
14213  ecode7 = SWIG_AsVal_double(args(4), &val7);
14214  if (!SWIG_IsOK(ecode7)) {
14215  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14216  }
14217  arg7 = (PLFLT)(val7);
14218  ecode8 = SWIG_AsVal_double(args(5), &val8);
14219  if (!SWIG_IsOK(ecode8)) {
14220  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14221  }
14222  arg8 = (PLFLT)(val8);
14223  ecode9 = SWIG_AsVal_double(args(6), &val9);
14224  if (!SWIG_IsOK(ecode9)) {
14225  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14226  }
14227  arg9 = (PLFLT)(val9);
14228  ecode10 = SWIG_AsVal_double(args(7), &val10);
14229  if (!SWIG_IsOK(ecode10)) {
14230  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14231  }
14232  arg10 = (PLFLT)(val10);
14233  ecode11 = SWIG_AsVal_double(args(8), &val11);
14234  if (!SWIG_IsOK(ecode11)) {
14235  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14236  }
14237  arg11 = (PLFLT)(val11);
14238  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14239  _outv = octave_value();
14240  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14241  {
14242 
14243  }
14244  return _out;
14245 fail:
14246  {
14247 
14248  }
14249  return octave_value_list();
14250 }
14251 
14252 
14253 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
14254  PLFLT *arg1 = (PLFLT *) 0 ;
14255  PLINT arg2 ;
14256  PLINT arg3 ;
14257  PLFLT arg4 ;
14258  PLFLT arg5 ;
14259  PLFLT arg6 ;
14260  PLFLT arg7 ;
14261  PLFLT arg8 ;
14262  PLFLT arg9 ;
14263  PLFLT arg10 ;
14264  PLFLT arg11 ;
14265  PLFLT *arg12 = (PLFLT *) 0 ;
14266  Matrix temp1 ;
14267  double val4 ;
14268  int ecode4 = 0 ;
14269  double val5 ;
14270  int ecode5 = 0 ;
14271  double val6 ;
14272  int ecode6 = 0 ;
14273  double val7 ;
14274  int ecode7 = 0 ;
14275  double val8 ;
14276  int ecode8 = 0 ;
14277  double val9 ;
14278  int ecode9 = 0 ;
14279  double val10 ;
14280  int ecode10 = 0 ;
14281  double val11 ;
14282  int ecode11 = 0 ;
14283  Matrix temp12 ;
14284  octave_value_list _out;
14285  octave_value_list *_outp=&_out;
14286  octave_value _outv;
14287 
14288  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
14289  SWIG_fail;
14290  }
14291  {
14292  if ( _n_dims( args(0) ) > 2 )
14293  {
14294  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14295  }
14296  temp1 = args(0).matrix_value();
14297  arg1 = &temp1( 0, 0 );
14298  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14299  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14300  }
14301  ecode4 = SWIG_AsVal_double(args(1), &val4);
14302  if (!SWIG_IsOK(ecode4)) {
14303  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
14304  }
14305  arg4 = (PLFLT)(val4);
14306  ecode5 = SWIG_AsVal_double(args(2), &val5);
14307  if (!SWIG_IsOK(ecode5)) {
14308  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
14309  }
14310  arg5 = (PLFLT)(val5);
14311  ecode6 = SWIG_AsVal_double(args(3), &val6);
14312  if (!SWIG_IsOK(ecode6)) {
14313  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
14314  }
14315  arg6 = (PLFLT)(val6);
14316  ecode7 = SWIG_AsVal_double(args(4), &val7);
14317  if (!SWIG_IsOK(ecode7)) {
14318  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
14319  }
14320  arg7 = (PLFLT)(val7);
14321  ecode8 = SWIG_AsVal_double(args(5), &val8);
14322  if (!SWIG_IsOK(ecode8)) {
14323  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
14324  }
14325  arg8 = (PLFLT)(val8);
14326  ecode9 = SWIG_AsVal_double(args(6), &val9);
14327  if (!SWIG_IsOK(ecode9)) {
14328  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
14329  }
14330  arg9 = (PLFLT)(val9);
14331  ecode10 = SWIG_AsVal_double(args(7), &val10);
14332  if (!SWIG_IsOK(ecode10)) {
14333  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
14334  }
14335  arg10 = (PLFLT)(val10);
14336  ecode11 = SWIG_AsVal_double(args(8), &val11);
14337  if (!SWIG_IsOK(ecode11)) {
14338  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
14339  }
14340  arg11 = (PLFLT)(val11);
14341  {
14342  if ( _n_dims( args(9) ) > 1 )
14343  {
14344  error( "argument must be a scalar or vector" ); SWIG_fail;
14345  }
14346  if ( _dim( args(9), 0 ) != 6 )
14347  {
14348  error( "argument vectors must have length of 6" ); SWIG_fail;
14349  }
14350  temp12 = args(9).matrix_value();
14351  arg12 = &temp12( 0, 0 );
14352  }
14353  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14354  _outv = octave_value();
14355  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14356  {
14357 
14358  }
14359  {
14360 
14361  }
14362  return _out;
14363 fail:
14364  {
14365 
14366  }
14367  {
14368 
14369  }
14370  return octave_value_list();
14371 }
14372 
14373 
14374 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
14375  PLFLT *arg1 = (PLFLT *) 0 ;
14376  PLINT arg2 ;
14377  PLINT arg3 ;
14378  PLFLT arg4 ;
14379  PLFLT arg5 ;
14380  PLFLT arg6 ;
14381  PLFLT arg7 ;
14382  PLFLT arg8 ;
14383  PLFLT arg9 ;
14384  PLFLT arg10 ;
14385  PLFLT arg11 ;
14386  PLFLT *arg12 = (PLFLT *) 0 ;
14387  PLFLT *arg13 = (PLFLT *) 0 ;
14388  Matrix temp1 ;
14389  double val4 ;
14390  int ecode4 = 0 ;
14391  double val5 ;
14392  int ecode5 = 0 ;
14393  double val6 ;
14394  int ecode6 = 0 ;
14395  double val7 ;
14396  int ecode7 = 0 ;
14397  double val8 ;
14398  int ecode8 = 0 ;
14399  double val9 ;
14400  int ecode9 = 0 ;
14401  double val10 ;
14402  int ecode10 = 0 ;
14403  double val11 ;
14404  int ecode11 = 0 ;
14405  Matrix temp12 ;
14406  Matrix temp13 ;
14407  octave_value_list _out;
14408  octave_value_list *_outp=&_out;
14409  octave_value _outv;
14410 
14411  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
14412  SWIG_fail;
14413  }
14414  {
14415  if ( _n_dims( args(0) ) > 2 )
14416  {
14417  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14418  }
14419  temp1 = args(0).matrix_value();
14420  arg1 = &temp1( 0, 0 );
14421  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14422  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14423  }
14424  ecode4 = SWIG_AsVal_double(args(1), &val4);
14425  if (!SWIG_IsOK(ecode4)) {
14426  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
14427  }
14428  arg4 = (PLFLT)(val4);
14429  ecode5 = SWIG_AsVal_double(args(2), &val5);
14430  if (!SWIG_IsOK(ecode5)) {
14431  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
14432  }
14433  arg5 = (PLFLT)(val5);
14434  ecode6 = SWIG_AsVal_double(args(3), &val6);
14435  if (!SWIG_IsOK(ecode6)) {
14436  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
14437  }
14438  arg6 = (PLFLT)(val6);
14439  ecode7 = SWIG_AsVal_double(args(4), &val7);
14440  if (!SWIG_IsOK(ecode7)) {
14441  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
14442  }
14443  arg7 = (PLFLT)(val7);
14444  ecode8 = SWIG_AsVal_double(args(5), &val8);
14445  if (!SWIG_IsOK(ecode8)) {
14446  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
14447  }
14448  arg8 = (PLFLT)(val8);
14449  ecode9 = SWIG_AsVal_double(args(6), &val9);
14450  if (!SWIG_IsOK(ecode9)) {
14451  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
14452  }
14453  arg9 = (PLFLT)(val9);
14454  ecode10 = SWIG_AsVal_double(args(7), &val10);
14455  if (!SWIG_IsOK(ecode10)) {
14456  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
14457  }
14458  arg10 = (PLFLT)(val10);
14459  ecode11 = SWIG_AsVal_double(args(8), &val11);
14460  if (!SWIG_IsOK(ecode11)) {
14461  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
14462  }
14463  arg11 = (PLFLT)(val11);
14464  {
14465  if ( _n_dims( args(9) ) > 1 )
14466  {
14467  error( "argument must be a scalar or vector" ); SWIG_fail;
14468  }
14469  if ( _dim( args(9), 0 ) != Xlen )
14470  {
14471  error( "argument vectors must be same length" ); SWIG_fail;
14472  }
14473  temp12 = args(9).matrix_value();
14474  arg12 = &temp12( 0, 0 );
14475  }
14476  {
14477  if ( _n_dims( args(10) ) > 1 )
14478  {
14479  error( "argument must be a scalar or vector" ); SWIG_fail;
14480  }
14481  if ( _dim( args(10), 0 ) != Ylen )
14482  {
14483  error( "argument vectors must be same length" ); SWIG_fail;
14484  }
14485  temp13 = args(10).matrix_value();
14486  arg13 = &temp13( 0, 0 );
14487  }
14488  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14489  _outv = octave_value();
14490  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14491  {
14492 
14493  }
14494  {
14495 
14496  }
14497  {
14498 
14499  }
14500  return _out;
14501 fail:
14502  {
14503 
14504  }
14505  {
14506 
14507  }
14508  {
14509 
14510  }
14511  return octave_value_list();
14512 }
14513 
14514 
14515 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
14516  PLFLT *arg1 = (PLFLT *) 0 ;
14517  PLINT arg2 ;
14518  PLINT arg3 ;
14519  PLFLT arg4 ;
14520  PLFLT arg5 ;
14521  PLFLT arg6 ;
14522  PLFLT arg7 ;
14523  PLFLT arg8 ;
14524  PLFLT arg9 ;
14525  PLFLT arg10 ;
14526  PLFLT arg11 ;
14527  PLFLT *arg12 = (PLFLT *) 0 ;
14528  PLFLT *arg13 = (PLFLT *) 0 ;
14529  Matrix temp1 ;
14530  double val4 ;
14531  int ecode4 = 0 ;
14532  double val5 ;
14533  int ecode5 = 0 ;
14534  double val6 ;
14535  int ecode6 = 0 ;
14536  double val7 ;
14537  int ecode7 = 0 ;
14538  double val8 ;
14539  int ecode8 = 0 ;
14540  double val9 ;
14541  int ecode9 = 0 ;
14542  double val10 ;
14543  int ecode10 = 0 ;
14544  double val11 ;
14545  int ecode11 = 0 ;
14546  Matrix temp12 ;
14547  Matrix temp13 ;
14548  octave_value_list _out;
14549  octave_value_list *_outp=&_out;
14550  octave_value _outv;
14551 
14552  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
14553  SWIG_fail;
14554  }
14555  {
14556  if ( _n_dims( args(0) ) > 2 )
14557  {
14558  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14559  }
14560  temp1 = args(0).matrix_value();
14561  arg1 = &temp1( 0, 0 );
14562  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14563  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14564  }
14565  ecode4 = SWIG_AsVal_double(args(1), &val4);
14566  if (!SWIG_IsOK(ecode4)) {
14567  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
14568  }
14569  arg4 = (PLFLT)(val4);
14570  ecode5 = SWIG_AsVal_double(args(2), &val5);
14571  if (!SWIG_IsOK(ecode5)) {
14572  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
14573  }
14574  arg5 = (PLFLT)(val5);
14575  ecode6 = SWIG_AsVal_double(args(3), &val6);
14576  if (!SWIG_IsOK(ecode6)) {
14577  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
14578  }
14579  arg6 = (PLFLT)(val6);
14580  ecode7 = SWIG_AsVal_double(args(4), &val7);
14581  if (!SWIG_IsOK(ecode7)) {
14582  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
14583  }
14584  arg7 = (PLFLT)(val7);
14585  ecode8 = SWIG_AsVal_double(args(5), &val8);
14586  if (!SWIG_IsOK(ecode8)) {
14587  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
14588  }
14589  arg8 = (PLFLT)(val8);
14590  ecode9 = SWIG_AsVal_double(args(6), &val9);
14591  if (!SWIG_IsOK(ecode9)) {
14592  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
14593  }
14594  arg9 = (PLFLT)(val9);
14595  ecode10 = SWIG_AsVal_double(args(7), &val10);
14596  if (!SWIG_IsOK(ecode10)) {
14597  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
14598  }
14599  arg10 = (PLFLT)(val10);
14600  ecode11 = SWIG_AsVal_double(args(8), &val11);
14601  if (!SWIG_IsOK(ecode11)) {
14602  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
14603  }
14604  arg11 = (PLFLT)(val11);
14605  {
14606  if ( _n_dims( args(9) ) > 2 )
14607  {
14608  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14609  }
14610  temp12 = args(9).matrix_value();
14611  arg12 = &temp12( 0, 0 );
14612  Xlen = (PLINT) ( _dim( args(9), 0 ) );
14613  Ylen = (PLINT) ( _dim( args(9), 1 ) );
14614  }
14615  {
14616  if ( _n_dims( args(10) ) > 2 )
14617  {
14618  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14619  }
14620  temp13 = args(10).matrix_value();
14621  arg13 = &temp13( 0, 0 );
14622  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14623  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14624  }
14625  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14626  _outv = octave_value();
14627  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14628  {
14629 
14630  }
14631  {
14632 
14633  }
14634  {
14635 
14636  }
14637  return _out;
14638 fail:
14639  {
14640 
14641  }
14642  {
14643 
14644  }
14645  {
14646 
14647  }
14648  return octave_value_list();
14649 }
14650 
14651 
14652 SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
14653  PLFLT *arg1 = (PLFLT *) 0 ;
14654  PLFLT *arg2 = (PLFLT *) 0 ;
14655  PLINT arg3 ;
14656  PLINT arg4 ;
14657  PLFLT arg5 ;
14658  PLFLT arg6 ;
14659  PLFLT arg7 ;
14660  PLFLT arg8 ;
14661  PLINT arg9 ;
14662  PLINT arg10 ;
14663  PLINT arg11 ;
14664  PLFLT arg12 ;
14665  PLFLT arg13 ;
14666  PLINT arg14 ;
14667  PLFLT arg15 ;
14668  PLINT arg16 ;
14669  PLINT *arg17 = (PLINT *) 0 ;
14670  char **arg18 = (char **) 0 ;
14671  PLINT arg19 ;
14672  char **arg20 = (char **) 0 ;
14673  PLFLT *arg21 = (PLFLT *) 0 ;
14674  PLINT *arg22 = (PLINT *) 0 ;
14675  PLINT *arg23 = (PLINT *) 0 ;
14676  PLFLT *arg24 = (PLFLT *) 0 ;
14677  PLFLT temp1 ;
14678  int res1 = SWIG_TMPOBJ ;
14679  PLFLT temp2 ;
14680  int res2 = SWIG_TMPOBJ ;
14681  int val3 ;
14682  int ecode3 = 0 ;
14683  int val4 ;
14684  int ecode4 = 0 ;
14685  double val5 ;
14686  int ecode5 = 0 ;
14687  double val6 ;
14688  int ecode6 = 0 ;
14689  double val7 ;
14690  int ecode7 = 0 ;
14691  double val8 ;
14692  int ecode8 = 0 ;
14693  int val9 ;
14694  int ecode9 = 0 ;
14695  int val10 ;
14696  int ecode10 = 0 ;
14697  int val11 ;
14698  int ecode11 = 0 ;
14699  double val12 ;
14700  int ecode12 = 0 ;
14701  double val13 ;
14702  int ecode13 = 0 ;
14703  int val14 ;
14704  int ecode14 = 0 ;
14705  double val15 ;
14706  int ecode15 = 0 ;
14707  Matrix temp16 ;
14708  Matrix temp21 ;
14709  Matrix temp22 ;
14710  Matrix temp23 ;
14711  Matrix temp24 ;
14712  octave_value_list _out;
14713  octave_value_list *_outp=&_out;
14714  octave_value _outv;
14715 
14716  arg1 = &temp1;
14717  arg2 = &temp2;
14718  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
14719  SWIG_fail;
14720  }
14721  ecode3 = SWIG_AsVal_int(args(0), &val3);
14722  if (!SWIG_IsOK(ecode3)) {
14723  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
14724  }
14725  arg3 = (PLINT)(val3);
14726  ecode4 = SWIG_AsVal_int(args(1), &val4);
14727  if (!SWIG_IsOK(ecode4)) {
14728  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
14729  }
14730  arg4 = (PLINT)(val4);
14731  ecode5 = SWIG_AsVal_double(args(2), &val5);
14732  if (!SWIG_IsOK(ecode5)) {
14733  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
14734  }
14735  arg5 = (PLFLT)(val5);
14736  ecode6 = SWIG_AsVal_double(args(3), &val6);
14737  if (!SWIG_IsOK(ecode6)) {
14738  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
14739  }
14740  arg6 = (PLFLT)(val6);
14741  ecode7 = SWIG_AsVal_double(args(4), &val7);
14742  if (!SWIG_IsOK(ecode7)) {
14743  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
14744  }
14745  arg7 = (PLFLT)(val7);
14746  ecode8 = SWIG_AsVal_double(args(5), &val8);
14747  if (!SWIG_IsOK(ecode8)) {
14748  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
14749  }
14750  arg8 = (PLFLT)(val8);
14751  ecode9 = SWIG_AsVal_int(args(6), &val9);
14752  if (!SWIG_IsOK(ecode9)) {
14753  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
14754  }
14755  arg9 = (PLINT)(val9);
14756  ecode10 = SWIG_AsVal_int(args(7), &val10);
14757  if (!SWIG_IsOK(ecode10)) {
14758  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
14759  }
14760  arg10 = (PLINT)(val10);
14761  ecode11 = SWIG_AsVal_int(args(8), &val11);
14762  if (!SWIG_IsOK(ecode11)) {
14763  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
14764  }
14765  arg11 = (PLINT)(val11);
14766  ecode12 = SWIG_AsVal_double(args(9), &val12);
14767  if (!SWIG_IsOK(ecode12)) {
14768  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
14769  }
14770  arg12 = (PLFLT)(val12);
14771  ecode13 = SWIG_AsVal_double(args(10), &val13);
14772  if (!SWIG_IsOK(ecode13)) {
14773  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
14774  }
14775  arg13 = (PLFLT)(val13);
14776  ecode14 = SWIG_AsVal_int(args(11), &val14);
14777  if (!SWIG_IsOK(ecode14)) {
14778  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
14779  }
14780  arg14 = (PLINT)(val14);
14781  ecode15 = SWIG_AsVal_double(args(12), &val15);
14782  if (!SWIG_IsOK(ecode15)) {
14783  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
14784  }
14785  arg15 = (PLFLT)(val15);
14786  {
14787  if ( _n_dims( args(13) ) > 1 )
14788  {
14789  error( "argument must be a scalar or vector" ); SWIG_fail;
14790  }
14791  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
14792  arg17 = new PLINT[Alen];
14793  temp16 = args(13).matrix_value();
14794  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
14795  }
14796  {
14797  charMatrix temp_matrix;
14798  Cell temp_cell;
14799  char *tmp_cstring;
14800  std::string str;
14801  size_t max_length = 0, non_blank_length;
14802  int i, ifcell;
14803  if ( _n_dims( args(14) ) > 2 )
14804  {
14805  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14806  }
14807  if ( !args(14).is_empty() )
14808  {
14809  if ( _dim( args(14), 0 ) != Alen )
14810  {
14811  error( "first dimension must be same length as previous vector" ); SWIG_fail;
14812  }
14813  arg18 = new char*[Alen];
14814  ifcell = args(14).is_cell();
14815  if ( ifcell )
14816  {
14817  temp_cell = args(14).cell_value();
14818  }
14819  else
14820  {
14821  temp_matrix = args(14).char_matrix_value();
14822  // Allow one extra space for null termination.
14823  max_length = _dim( args(14), 1 ) + 1;
14824  }
14825 
14826  for ( i = 0; i < Alen; i++ )
14827  {
14828  // Must copy string to "permanent" location because the string
14829  // location corresponding to tmp_cstring gets
14830  // overwritten for each iteration of loop.
14831  if ( ifcell )
14832  {
14833  if ( temp_cell.elem( i ).is_string() )
14834  {
14835  str = temp_cell.elem( i ).string_value();
14836  // leave room for null termination.
14837  max_length = str.size() + 1;
14838  tmp_cstring = (char *) str.c_str();
14839  }
14840  else
14841  {
14842  // Use null string if user attempts to pass a cell array
14843  // with a non-string element (likely an empty element
14844  // since that should be allowed by the PLplot interface
14845  // if that element is going to be unused).
14846  // leave room for null termination.
14847  max_length = 1;
14848  tmp_cstring = (char *) "";
14849  }
14850  }
14851  else
14852  {
14853  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14854  }
14855  arg18[i] = new char[max_length];
14856  strncpy( arg18[i], tmp_cstring, max_length - 1 );
14857  arg18[i][max_length - 1] = '\0';
14858  // All the trailing blank crapola should not be needed for
14859  // string cell arrays.
14860  if ( !ifcell )
14861  {
14862  // remove trailing-blank padding that is used by the
14863  // charMatrix class to insure all strings in a given
14864  // charMatrix instance have the same length.
14865  // This transformation also removes legitimate trailing
14866  // blanks but there is nothing we can do about that
14867  // for the charMatrix class.
14868 
14869  // Look for trailing nulls first (just in case, although that
14870  // shouldn't happen if charMatrix implemented as documented)
14871  // before looking for trailing blanks.
14872  non_blank_length = max_length - 2;
14873  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
14874  {
14875  non_blank_length--;
14876  }
14877  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
14878  {
14879  non_blank_length--;
14880  }
14881  arg18[i][non_blank_length + 1] = '\0';
14882  }
14883  }
14884  }
14885  else
14886  {
14887  arg18 = NULL;
14888  }
14889  }
14890  {
14891  charMatrix temp_matrix;
14892  Cell temp_cell;
14893  char *tmp_cstring;
14894  std::string str;
14895  size_t max_length = 0, non_blank_length;
14896  int i, ifcell;
14897  if ( _n_dims( args(15) ) > 2 )
14898  {
14899  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
14900  }
14901  if ( !args(15).is_empty() )
14902  {
14903  Alen = _dim( args(15), 0 );
14904  arg19 = Alen;
14905  arg20 = new char*[Alen];
14906  ifcell = args(15).is_cell();
14907  if ( ifcell )
14908  {
14909  temp_cell = args(15).cell_value();
14910  }
14911  else
14912  {
14913  temp_matrix = args(15).char_matrix_value();
14914  // Allow one extra space for null termination.
14915  max_length = _dim( args(15), 1 ) + 1;
14916  }
14917 
14918  for ( i = 0; i < Alen; i++ )
14919  {
14920  // Must copy string to "permanent" location because the string
14921  // location corresponding to tmp_cstring gets
14922  // overwritten for each iteration of loop.
14923  if ( ifcell )
14924  {
14925  if ( temp_cell.elem( i ).is_string() )
14926  {
14927  str = temp_cell.elem( i ).string_value();
14928  // leave room for null termination.
14929  max_length = str.size() + 1;
14930  tmp_cstring = (char *) str.c_str();
14931  }
14932  else
14933  {
14934  // Use null string if user attempts to pass a cell array
14935  // with a non-string element (likely an empty element
14936  // since that should be allowed by the PLplot interface
14937  // if that element is going to be unused).
14938  // leave room for null termination.
14939  max_length = 1;
14940  tmp_cstring = (char *) "";
14941  }
14942  }
14943  else
14944  {
14945  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
14946  }
14947  arg20[i] = new char[max_length];
14948  strncpy( arg20[i], tmp_cstring, max_length - 1 );
14949  arg20[i][max_length - 1] = '\0';
14950  // All the trailing blank crapola should not be needed for
14951  // string cell arrays.
14952  if ( !ifcell )
14953  {
14954  // remove trailing-blank padding that is used by the
14955  // charMatrix class to insure all strings in a given
14956  // charMatrix instance have the same length.
14957  // This transformation also removes legitimate trailing
14958  // blanks but there is nothing we can do about that
14959  // for the charMatrix class.
14960 
14961  // Look for trailing nulls first (just in case, although that
14962  // shouldn't happen if charMatrix implemented as documented)
14963  // before looking for trailing blanks.
14964  non_blank_length = max_length - 2;
14965  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
14966  {
14967  non_blank_length--;
14968  }
14969  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
14970  {
14971  non_blank_length--;
14972  }
14973  arg20[i][non_blank_length + 1] = '\0';
14974  }
14975  }
14976  }
14977  else
14978  {
14979  arg19 = 0;
14980  arg20 = NULL;
14981  }
14982  }
14983  {
14984  if ( _n_dims( args(16) ) > 1 )
14985  {
14986  error( "argument must be a scalar or vector" ); SWIG_fail;
14987  }
14988  if ( _dim( args(16), 0 ) != Alen )
14989  {
14990  error( "argument vectors must be same length" ); SWIG_fail;
14991  }
14992  temp21 = args(16).matrix_value();
14993  arg21 = &temp21( 0, 0 );
14994  }
14995  {
14996  if ( _n_dims( args(17) ) > 1 )
14997  {
14998  error( "argument must be a scalar or vector" ); SWIG_fail;
14999  }
15000  if ( _dim( args(17), 0 ) != Alen )
15001  {
15002  error( "argument vectors must be same length" ); SWIG_fail;
15003  }
15004  temp22 = args(17).matrix_value();
15005  arg22 = new PLINT[Alen];
15006  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15007  }
15008  {
15009  int i;
15010  if ( _n_dims( args(18) ) > 1 )
15011  {
15012  error( "argument must be a scalar or vector" ); SWIG_fail;
15013  }
15014  if ( _dim( args(18), 0 ) != Alen )
15015  {
15016  error( "argument vectors must be same length" ); SWIG_fail;
15017  }
15018  Xlen = Alen;
15019  temp23 = args(18).matrix_value();
15020  arg23 = new PLINT[Alen];
15021  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15022  Ylen = -1;
15023  for ( i = 0; i < Xlen; i++ )
15024  if ( arg23[i] > Ylen )
15025  Ylen = arg23[i];
15026  }
15027  {
15028  if ( _n_dims( args(19) ) > 2 )
15029  {
15030  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15031  }
15032  if ( _dim( args(19), 0 ) != Xlen )
15033  {
15034  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15035  }
15036  if ( _dim( args(19), 1 ) != Ylen )
15037  {
15038  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15039  }
15040  temp24 = args(19).matrix_value();
15041  arg24 = &temp24( 0, 0 );
15042  }
15043  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);
15044  _outv = octave_value();
15045  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15046  if (SWIG_IsTmpObj(res1)) {
15047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15048  } else {
15049  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15050  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15051  }
15052  if (SWIG_IsTmpObj(res2)) {
15053  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15054  } else {
15055  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15056  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15057  }
15058  {
15059  delete [] arg17;
15060  }
15061  {
15062  int i;
15063  if ( arg18 != NULL )
15064  {
15065  for ( i = 0; i < Alen; i++ )
15066  {
15067  delete[] arg18[i];
15068  }
15069  delete[] arg18;
15070  }
15071  }
15072  {
15073  int i;
15074  if ( arg20 != NULL )
15075  {
15076  for ( i = 0; i < Alen; i++ )
15077  {
15078  delete[] arg20[i];
15079  }
15080  delete[] arg20;
15081  }
15082  }
15083  {
15084 
15085  }
15086  {
15087  delete [] arg22;
15088  }
15089  {
15090  delete [] arg23;
15091  }
15092  {
15093 
15094  }
15095  return _out;
15096 fail:
15097  {
15098  delete [] arg17;
15099  }
15100  {
15101  int i;
15102  if ( arg18 != NULL )
15103  {
15104  for ( i = 0; i < Alen; i++ )
15105  {
15106  delete[] arg18[i];
15107  }
15108  delete[] arg18;
15109  }
15110  }
15111  {
15112  int i;
15113  if ( arg20 != NULL )
15114  {
15115  for ( i = 0; i < Alen; i++ )
15116  {
15117  delete[] arg20[i];
15118  }
15119  delete[] arg20;
15120  }
15121  }
15122  {
15123 
15124  }
15125  {
15126  delete [] arg22;
15127  }
15128  {
15129  delete [] arg23;
15130  }
15131  {
15132 
15133  }
15134  return octave_value_list();
15135 }
15136 
15137 
15139  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15140  int arg2 ;
15141  void *argp1 = 0 ;
15142  int res1 = 0 ;
15143  int val2 ;
15144  int ecode2 = 0 ;
15145  octave_value_list _out;
15146  octave_value_list *_outp=&_out;
15147  octave_value _outv;
15148 
15149  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
15150  SWIG_fail;
15151  }
15152  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15153  if (!SWIG_IsOK(res1)) {
15154  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15155  }
15156  arg1 = (PLGraphicsIn *)(argp1);
15157  ecode2 = SWIG_AsVal_int(args(1), &val2);
15158  if (!SWIG_IsOK(ecode2)) {
15159  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
15160  }
15161  arg2 = (int)(val2);
15162  if (arg1) (arg1)->type = arg2;
15163  _outv = octave_value();
15164  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15165  return _out;
15166 fail:
15167  return octave_value_list();
15168 }
15169 
15170 
15172  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15173  void *argp1 = 0 ;
15174  int res1 = 0 ;
15175  octave_value_list _out;
15176  octave_value_list *_outp=&_out;
15177  octave_value _outv;
15178  int result;
15179 
15180  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
15181  SWIG_fail;
15182  }
15183  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15184  if (!SWIG_IsOK(res1)) {
15185  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15186  }
15187  arg1 = (PLGraphicsIn *)(argp1);
15188  result = (int) ((arg1)->type);
15189  _outv = SWIG_From_int((int)(result));
15190  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15191  return _out;
15192 fail:
15193  return octave_value_list();
15194 }
15195 
15196 
15197 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
15198  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15199  unsigned int arg2 ;
15200  void *argp1 = 0 ;
15201  int res1 = 0 ;
15202  unsigned int val2 ;
15203  int ecode2 = 0 ;
15204  octave_value_list _out;
15205  octave_value_list *_outp=&_out;
15206  octave_value _outv;
15207 
15208  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
15209  SWIG_fail;
15210  }
15211  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15212  if (!SWIG_IsOK(res1)) {
15213  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15214  }
15215  arg1 = (PLGraphicsIn *)(argp1);
15216  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15217  if (!SWIG_IsOK(ecode2)) {
15218  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
15219  }
15220  arg2 = (unsigned int)(val2);
15221  if (arg1) (arg1)->state = arg2;
15222  _outv = octave_value();
15223  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15224  return _out;
15225 fail:
15226  return octave_value_list();
15227 }
15228 
15229 
15230 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
15231  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15232  void *argp1 = 0 ;
15233  int res1 = 0 ;
15234  octave_value_list _out;
15235  octave_value_list *_outp=&_out;
15236  octave_value _outv;
15237  unsigned int result;
15238 
15239  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
15240  SWIG_fail;
15241  }
15242  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15243  if (!SWIG_IsOK(res1)) {
15244  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15245  }
15246  arg1 = (PLGraphicsIn *)(argp1);
15247  result = (unsigned int) ((arg1)->state);
15248  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
15249  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15250  return _out;
15251 fail:
15252  return octave_value_list();
15253 }
15254 
15255 
15256 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
15257  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15258  unsigned int arg2 ;
15259  void *argp1 = 0 ;
15260  int res1 = 0 ;
15261  unsigned int val2 ;
15262  int ecode2 = 0 ;
15263  octave_value_list _out;
15264  octave_value_list *_outp=&_out;
15265  octave_value _outv;
15266 
15267  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
15268  SWIG_fail;
15269  }
15270  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15271  if (!SWIG_IsOK(res1)) {
15272  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15273  }
15274  arg1 = (PLGraphicsIn *)(argp1);
15275  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15276  if (!SWIG_IsOK(ecode2)) {
15277  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
15278  }
15279  arg2 = (unsigned int)(val2);
15280  if (arg1) (arg1)->keysym = arg2;
15281  _outv = octave_value();
15282  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15283  return _out;
15284 fail:
15285  return octave_value_list();
15286 }
15287 
15288 
15289 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
15290  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15291  void *argp1 = 0 ;
15292  int res1 = 0 ;
15293  octave_value_list _out;
15294  octave_value_list *_outp=&_out;
15295  octave_value _outv;
15296  unsigned int result;
15297 
15298  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
15299  SWIG_fail;
15300  }
15301  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15302  if (!SWIG_IsOK(res1)) {
15303  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15304  }
15305  arg1 = (PLGraphicsIn *)(argp1);
15306  result = (unsigned int) ((arg1)->keysym);
15307  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
15308  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15309  return _out;
15310 fail:
15311  return octave_value_list();
15312 }
15313 
15314 
15315 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
15316  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15317  unsigned int arg2 ;
15318  void *argp1 = 0 ;
15319  int res1 = 0 ;
15320  unsigned int val2 ;
15321  int ecode2 = 0 ;
15322  octave_value_list _out;
15323  octave_value_list *_outp=&_out;
15324  octave_value _outv;
15325 
15326  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
15327  SWIG_fail;
15328  }
15329  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15330  if (!SWIG_IsOK(res1)) {
15331  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15332  }
15333  arg1 = (PLGraphicsIn *)(argp1);
15334  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15335  if (!SWIG_IsOK(ecode2)) {
15336  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
15337  }
15338  arg2 = (unsigned int)(val2);
15339  if (arg1) (arg1)->button = arg2;
15340  _outv = octave_value();
15341  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15342  return _out;
15343 fail:
15344  return octave_value_list();
15345 }
15346 
15347 
15348 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
15349  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15350  void *argp1 = 0 ;
15351  int res1 = 0 ;
15352  octave_value_list _out;
15353  octave_value_list *_outp=&_out;
15354  octave_value _outv;
15355  unsigned int result;
15356 
15357  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
15358  SWIG_fail;
15359  }
15360  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15361  if (!SWIG_IsOK(res1)) {
15362  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15363  }
15364  arg1 = (PLGraphicsIn *)(argp1);
15365  result = (unsigned int) ((arg1)->button);
15366  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
15367  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15368  return _out;
15369 fail:
15370  return octave_value_list();
15371 }
15372 
15373 
15374 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
15375  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15376  PLINT arg2 ;
15377  void *argp1 = 0 ;
15378  int res1 = 0 ;
15379  int val2 ;
15380  int ecode2 = 0 ;
15381  octave_value_list _out;
15382  octave_value_list *_outp=&_out;
15383  octave_value _outv;
15384 
15385  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
15386  SWIG_fail;
15387  }
15388  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15389  if (!SWIG_IsOK(res1)) {
15390  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15391  }
15392  arg1 = (PLGraphicsIn *)(argp1);
15393  ecode2 = SWIG_AsVal_int(args(1), &val2);
15394  if (!SWIG_IsOK(ecode2)) {
15395  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
15396  }
15397  arg2 = (PLINT)(val2);
15398  if (arg1) (arg1)->subwindow = arg2;
15399  _outv = octave_value();
15400  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15401  return _out;
15402 fail:
15403  return octave_value_list();
15404 }
15405 
15406 
15407 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
15408  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15409  void *argp1 = 0 ;
15410  int res1 = 0 ;
15411  octave_value_list _out;
15412  octave_value_list *_outp=&_out;
15413  octave_value _outv;
15414  PLINT result;
15415 
15416  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
15417  SWIG_fail;
15418  }
15419  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15420  if (!SWIG_IsOK(res1)) {
15421  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15422  }
15423  arg1 = (PLGraphicsIn *)(argp1);
15424  result = (PLINT) ((arg1)->subwindow);
15425  _outv = SWIG_From_int((int)(result));
15426  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15427  return _out;
15428 fail:
15429  return octave_value_list();
15430 }
15431 
15432 
15433 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
15434  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15435  char *arg2 ;
15436  void *argp1 = 0 ;
15437  int res1 = 0 ;
15438  char temp2[16] ;
15439  int res2 ;
15440  octave_value_list _out;
15441  octave_value_list *_outp=&_out;
15442  octave_value _outv;
15443 
15444  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
15445  SWIG_fail;
15446  }
15447  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15448  if (!SWIG_IsOK(res1)) {
15449  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15450  }
15451  arg1 = (PLGraphicsIn *)(argp1);
15452  res2 = SWIG_AsCharArray(args(1), temp2, 16);
15453  if (!SWIG_IsOK(res2)) {
15454  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
15455  }
15456  arg2 = (char *)(temp2);
15457  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
15458  else memset(arg1->string,0,16*sizeof(char));
15459  _outv = octave_value();
15460  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15461  return _out;
15462 fail:
15463  return octave_value_list();
15464 }
15465 
15466 
15467 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
15468  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15469  void *argp1 = 0 ;
15470  int res1 = 0 ;
15471  octave_value_list _out;
15472  octave_value_list *_outp=&_out;
15473  octave_value _outv;
15474  char *result = 0 ;
15475 
15476  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
15477  SWIG_fail;
15478  }
15479  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15480  if (!SWIG_IsOK(res1)) {
15481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15482  }
15483  arg1 = (PLGraphicsIn *)(argp1);
15484  result = (char *)(char *) ((arg1)->string);
15485  {
15486  size_t size = 16;
15487 
15488  while (size && (result[size - 1] == '\0')) --size;
15489 
15490  _outv = SWIG_FromCharPtrAndSize(result, size);
15491  }
15492  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15493  return _out;
15494 fail:
15495  return octave_value_list();
15496 }
15497 
15498 
15500  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15501  int arg2 ;
15502  void *argp1 = 0 ;
15503  int res1 = 0 ;
15504  int val2 ;
15505  int ecode2 = 0 ;
15506  octave_value_list _out;
15507  octave_value_list *_outp=&_out;
15508  octave_value _outv;
15509 
15510  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
15511  SWIG_fail;
15512  }
15513  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15514  if (!SWIG_IsOK(res1)) {
15515  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15516  }
15517  arg1 = (PLGraphicsIn *)(argp1);
15518  ecode2 = SWIG_AsVal_int(args(1), &val2);
15519  if (!SWIG_IsOK(ecode2)) {
15520  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
15521  }
15522  arg2 = (int)(val2);
15523  if (arg1) (arg1)->pX = arg2;
15524  _outv = octave_value();
15525  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15526  return _out;
15527 fail:
15528  return octave_value_list();
15529 }
15530 
15531 
15533  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15534  void *argp1 = 0 ;
15535  int res1 = 0 ;
15536  octave_value_list _out;
15537  octave_value_list *_outp=&_out;
15538  octave_value _outv;
15539  int result;
15540 
15541  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
15542  SWIG_fail;
15543  }
15544  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15545  if (!SWIG_IsOK(res1)) {
15546  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15547  }
15548  arg1 = (PLGraphicsIn *)(argp1);
15549  result = (int) ((arg1)->pX);
15550  _outv = SWIG_From_int((int)(result));
15551  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15552  return _out;
15553 fail:
15554  return octave_value_list();
15555 }
15556 
15557 
15559  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15560  int arg2 ;
15561  void *argp1 = 0 ;
15562  int res1 = 0 ;
15563  int val2 ;
15564  int ecode2 = 0 ;
15565  octave_value_list _out;
15566  octave_value_list *_outp=&_out;
15567  octave_value _outv;
15568 
15569  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
15570  SWIG_fail;
15571  }
15572  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15573  if (!SWIG_IsOK(res1)) {
15574  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15575  }
15576  arg1 = (PLGraphicsIn *)(argp1);
15577  ecode2 = SWIG_AsVal_int(args(1), &val2);
15578  if (!SWIG_IsOK(ecode2)) {
15579  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
15580  }
15581  arg2 = (int)(val2);
15582  if (arg1) (arg1)->pY = arg2;
15583  _outv = octave_value();
15584  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15585  return _out;
15586 fail:
15587  return octave_value_list();
15588 }
15589 
15590 
15592  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15593  void *argp1 = 0 ;
15594  int res1 = 0 ;
15595  octave_value_list _out;
15596  octave_value_list *_outp=&_out;
15597  octave_value _outv;
15598  int result;
15599 
15600  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
15601  SWIG_fail;
15602  }
15603  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15604  if (!SWIG_IsOK(res1)) {
15605  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15606  }
15607  arg1 = (PLGraphicsIn *)(argp1);
15608  result = (int) ((arg1)->pY);
15609  _outv = SWIG_From_int((int)(result));
15610  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15611  return _out;
15612 fail:
15613  return octave_value_list();
15614 }
15615 
15616 
15618  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15619  PLFLT arg2 ;
15620  void *argp1 = 0 ;
15621  int res1 = 0 ;
15622  double val2 ;
15623  int ecode2 = 0 ;
15624  octave_value_list _out;
15625  octave_value_list *_outp=&_out;
15626  octave_value _outv;
15627 
15628  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
15629  SWIG_fail;
15630  }
15631  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15632  if (!SWIG_IsOK(res1)) {
15633  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15634  }
15635  arg1 = (PLGraphicsIn *)(argp1);
15636  ecode2 = SWIG_AsVal_double(args(1), &val2);
15637  if (!SWIG_IsOK(ecode2)) {
15638  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
15639  }
15640  arg2 = (PLFLT)(val2);
15641  if (arg1) (arg1)->dX = arg2;
15642  _outv = octave_value();
15643  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15644  return _out;
15645 fail:
15646  return octave_value_list();
15647 }
15648 
15649 
15651  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15652  void *argp1 = 0 ;
15653  int res1 = 0 ;
15654  octave_value_list _out;
15655  octave_value_list *_outp=&_out;
15656  octave_value _outv;
15657  PLFLT result;
15658 
15659  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
15660  SWIG_fail;
15661  }
15662  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15663  if (!SWIG_IsOK(res1)) {
15664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15665  }
15666  arg1 = (PLGraphicsIn *)(argp1);
15667  result = (PLFLT) ((arg1)->dX);
15668  _outv = SWIG_From_double((double)(result));
15669  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15670  return _out;
15671 fail:
15672  return octave_value_list();
15673 }
15674 
15675 
15677  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15678  PLFLT arg2 ;
15679  void *argp1 = 0 ;
15680  int res1 = 0 ;
15681  double val2 ;
15682  int ecode2 = 0 ;
15683  octave_value_list _out;
15684  octave_value_list *_outp=&_out;
15685  octave_value _outv;
15686 
15687  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
15688  SWIG_fail;
15689  }
15690  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15691  if (!SWIG_IsOK(res1)) {
15692  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15693  }
15694  arg1 = (PLGraphicsIn *)(argp1);
15695  ecode2 = SWIG_AsVal_double(args(1), &val2);
15696  if (!SWIG_IsOK(ecode2)) {
15697  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
15698  }
15699  arg2 = (PLFLT)(val2);
15700  if (arg1) (arg1)->dY = arg2;
15701  _outv = octave_value();
15702  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15703  return _out;
15704 fail:
15705  return octave_value_list();
15706 }
15707 
15708 
15710  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15711  void *argp1 = 0 ;
15712  int res1 = 0 ;
15713  octave_value_list _out;
15714  octave_value_list *_outp=&_out;
15715  octave_value _outv;
15716  PLFLT result;
15717 
15718  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
15719  SWIG_fail;
15720  }
15721  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15722  if (!SWIG_IsOK(res1)) {
15723  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15724  }
15725  arg1 = (PLGraphicsIn *)(argp1);
15726  result = (PLFLT) ((arg1)->dY);
15727  _outv = SWIG_From_double((double)(result));
15728  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15729  return _out;
15730 fail:
15731  return octave_value_list();
15732 }
15733 
15734 
15736  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15737  PLFLT arg2 ;
15738  void *argp1 = 0 ;
15739  int res1 = 0 ;
15740  double val2 ;
15741  int ecode2 = 0 ;
15742  octave_value_list _out;
15743  octave_value_list *_outp=&_out;
15744  octave_value _outv;
15745 
15746  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
15747  SWIG_fail;
15748  }
15749  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15750  if (!SWIG_IsOK(res1)) {
15751  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15752  }
15753  arg1 = (PLGraphicsIn *)(argp1);
15754  ecode2 = SWIG_AsVal_double(args(1), &val2);
15755  if (!SWIG_IsOK(ecode2)) {
15756  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
15757  }
15758  arg2 = (PLFLT)(val2);
15759  if (arg1) (arg1)->wX = arg2;
15760  _outv = octave_value();
15761  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15762  return _out;
15763 fail:
15764  return octave_value_list();
15765 }
15766 
15767 
15769  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15770  void *argp1 = 0 ;
15771  int res1 = 0 ;
15772  octave_value_list _out;
15773  octave_value_list *_outp=&_out;
15774  octave_value _outv;
15775  PLFLT result;
15776 
15777  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
15778  SWIG_fail;
15779  }
15780  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15781  if (!SWIG_IsOK(res1)) {
15782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15783  }
15784  arg1 = (PLGraphicsIn *)(argp1);
15785  result = (PLFLT) ((arg1)->wX);
15786  _outv = SWIG_From_double((double)(result));
15787  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15788  return _out;
15789 fail:
15790  return octave_value_list();
15791 }
15792 
15793 
15795  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15796  PLFLT arg2 ;
15797  void *argp1 = 0 ;
15798  int res1 = 0 ;
15799  double val2 ;
15800  int ecode2 = 0 ;
15801  octave_value_list _out;
15802  octave_value_list *_outp=&_out;
15803  octave_value _outv;
15804 
15805  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
15806  SWIG_fail;
15807  }
15808  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15809  if (!SWIG_IsOK(res1)) {
15810  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15811  }
15812  arg1 = (PLGraphicsIn *)(argp1);
15813  ecode2 = SWIG_AsVal_double(args(1), &val2);
15814  if (!SWIG_IsOK(ecode2)) {
15815  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
15816  }
15817  arg2 = (PLFLT)(val2);
15818  if (arg1) (arg1)->wY = arg2;
15819  _outv = octave_value();
15820  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15821  return _out;
15822 fail:
15823  return octave_value_list();
15824 }
15825 
15826 
15828  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15829  void *argp1 = 0 ;
15830  int res1 = 0 ;
15831  octave_value_list _out;
15832  octave_value_list *_outp=&_out;
15833  octave_value _outv;
15834  PLFLT result;
15835 
15836  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
15837  SWIG_fail;
15838  }
15839  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15840  if (!SWIG_IsOK(res1)) {
15841  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15842  }
15843  arg1 = (PLGraphicsIn *)(argp1);
15844  result = (PLFLT) ((arg1)->wY);
15845  _outv = SWIG_From_double((double)(result));
15846  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15847  return _out;
15848 fail:
15849  return octave_value_list();
15850 }
15851 
15852 
15854  octave_value_list _out;
15855  octave_value_list *_outp=&_out;
15856  octave_value _outv;
15857  PLGraphicsIn *result = 0 ;
15858 
15859  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
15860  SWIG_fail;
15861  }
15862  result = (PLGraphicsIn *)new PLGraphicsIn();
15864  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15865  return _out;
15866 fail:
15867  return octave_value_list();
15868 }
15869 
15870 
15872  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15873  void *argp1 = 0 ;
15874  int res1 = 0 ;
15875  octave_value_list _out;
15876  octave_value_list *_outp=&_out;
15877  octave_value _outv;
15878 
15879  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
15880  SWIG_fail;
15881  }
15882  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
15883  if (!SWIG_IsOK(res1)) {
15884  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15885  }
15886  arg1 = (PLGraphicsIn *)(argp1);
15887  delete arg1;
15888  _outv = octave_value();
15889  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15890  return _out;
15891 fail:
15892  return octave_value_list();
15893 }
15894 
15895 
15909 {0,0,0,0}
15910 };
15911 static const char *swig_PLGraphicsIn_base_names[] = {0};
15914 
15915 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
15916  PLINT arg1 ;
15917  PLINT arg2 ;
15918  int val1 ;
15919  int ecode1 = 0 ;
15920  int val2 ;
15921  int ecode2 = 0 ;
15922  octave_value_list _out;
15923  octave_value_list *_outp=&_out;
15924  octave_value _outv;
15925 
15926  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
15927  SWIG_fail;
15928  }
15929  ecode1 = SWIG_AsVal_int(args(0), &val1);
15930  if (!SWIG_IsOK(ecode1)) {
15931  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
15932  }
15933  arg1 = (PLINT)(val1);
15934  ecode2 = SWIG_AsVal_int(args(1), &val2);
15935  if (!SWIG_IsOK(ecode2)) {
15936  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
15937  }
15938  arg2 = (PLINT)(val2);
15939  pl_setcontlabelformat(arg1,arg2);
15940  _outv = octave_value();
15941  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15942  return _out;
15943 fail:
15944  return octave_value_list();
15945 }
15946 
15947 
15948 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
15949  PLFLT arg1 ;
15950  PLFLT arg2 ;
15951  PLFLT arg3 ;
15952  PLINT arg4 ;
15953  double val1 ;
15954  int ecode1 = 0 ;
15955  double val2 ;
15956  int ecode2 = 0 ;
15957  double val3 ;
15958  int ecode3 = 0 ;
15959  int val4 ;
15960  int ecode4 = 0 ;
15961  octave_value_list _out;
15962  octave_value_list *_outp=&_out;
15963  octave_value _outv;
15964 
15965  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
15966  SWIG_fail;
15967  }
15968  ecode1 = SWIG_AsVal_double(args(0), &val1);
15969  if (!SWIG_IsOK(ecode1)) {
15970  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
15971  }
15972  arg1 = (PLFLT)(val1);
15973  ecode2 = SWIG_AsVal_double(args(1), &val2);
15974  if (!SWIG_IsOK(ecode2)) {
15975  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
15976  }
15977  arg2 = (PLFLT)(val2);
15978  ecode3 = SWIG_AsVal_double(args(2), &val3);
15979  if (!SWIG_IsOK(ecode3)) {
15980  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
15981  }
15982  arg3 = (PLFLT)(val3);
15983  ecode4 = SWIG_AsVal_int(args(3), &val4);
15984  if (!SWIG_IsOK(ecode4)) {
15985  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
15986  }
15987  arg4 = (PLINT)(val4);
15988  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
15989  _outv = octave_value();
15990  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15991  return _out;
15992 fail:
15993  return octave_value_list();
15994 }
15995 
15996 
15997 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
15998  PLINT arg1 ;
15999  int val1 ;
16000  int ecode1 = 0 ;
16001  octave_value_list _out;
16002  octave_value_list *_outp=&_out;
16003  octave_value _outv;
16004 
16005  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
16006  SWIG_fail;
16007  }
16008  ecode1 = SWIG_AsVal_int(args(0), &val1);
16009  if (!SWIG_IsOK(ecode1)) {
16010  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
16011  }
16012  arg1 = (PLINT)(val1);
16013  pladv(arg1);
16014  _outv = octave_value();
16015  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16016  return _out;
16017 fail:
16018  return octave_value_list();
16019 }
16020 
16021 
16022 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
16023  PLFLT arg1 ;
16024  PLFLT arg2 ;
16025  PLFLT arg3 ;
16026  PLFLT arg4 ;
16027  PLFLT arg5 ;
16028  PLFLT arg6 ;
16029  PLFLT arg7 ;
16030  PLBOOL arg8 ;
16031  double val1 ;
16032  int ecode1 = 0 ;
16033  double val2 ;
16034  int ecode2 = 0 ;
16035  double val3 ;
16036  int ecode3 = 0 ;
16037  double val4 ;
16038  int ecode4 = 0 ;
16039  double val5 ;
16040  int ecode5 = 0 ;
16041  double val6 ;
16042  int ecode6 = 0 ;
16043  double val7 ;
16044  int ecode7 = 0 ;
16045  int val8 ;
16046  int ecode8 = 0 ;
16047  octave_value_list _out;
16048  octave_value_list *_outp=&_out;
16049  octave_value _outv;
16050 
16051  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
16052  SWIG_fail;
16053  }
16054  ecode1 = SWIG_AsVal_double(args(0), &val1);
16055  if (!SWIG_IsOK(ecode1)) {
16056  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
16057  }
16058  arg1 = (PLFLT)(val1);
16059  ecode2 = SWIG_AsVal_double(args(1), &val2);
16060  if (!SWIG_IsOK(ecode2)) {
16061  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
16062  }
16063  arg2 = (PLFLT)(val2);
16064  ecode3 = SWIG_AsVal_double(args(2), &val3);
16065  if (!SWIG_IsOK(ecode3)) {
16066  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
16067  }
16068  arg3 = (PLFLT)(val3);
16069  ecode4 = SWIG_AsVal_double(args(3), &val4);
16070  if (!SWIG_IsOK(ecode4)) {
16071  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
16072  }
16073  arg4 = (PLFLT)(val4);
16074  ecode5 = SWIG_AsVal_double(args(4), &val5);
16075  if (!SWIG_IsOK(ecode5)) {
16076  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
16077  }
16078  arg5 = (PLFLT)(val5);
16079  ecode6 = SWIG_AsVal_double(args(5), &val6);
16080  if (!SWIG_IsOK(ecode6)) {
16081  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
16082  }
16083  arg6 = (PLFLT)(val6);
16084  ecode7 = SWIG_AsVal_double(args(6), &val7);
16085  if (!SWIG_IsOK(ecode7)) {
16086  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
16087  }
16088  arg7 = (PLFLT)(val7);
16089  ecode8 = SWIG_AsVal_int(args(7), &val8);
16090  if (!SWIG_IsOK(ecode8)) {
16091  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
16092  }
16093  arg8 = (PLBOOL)(val8);
16094  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16095  _outv = octave_value();
16096  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16097  return _out;
16098 fail:
16099  return octave_value_list();
16100 }
16101 
16102 
16103 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
16104  PLFLT arg1 ;
16105  PLFLT arg2 ;
16106  char *arg3 = (char *) 0 ;
16107  PLFLT arg4 ;
16108  PLINT arg5 ;
16109  char *arg6 = (char *) 0 ;
16110  PLFLT arg7 ;
16111  PLINT arg8 ;
16112  double val1 ;
16113  int ecode1 = 0 ;
16114  double val2 ;
16115  int ecode2 = 0 ;
16116  int res3 ;
16117  char *buf3 = 0 ;
16118  int alloc3 = 0 ;
16119  double val4 ;
16120  int ecode4 = 0 ;
16121  int val5 ;
16122  int ecode5 = 0 ;
16123  int res6 ;
16124  char *buf6 = 0 ;
16125  int alloc6 = 0 ;
16126  double val7 ;
16127  int ecode7 = 0 ;
16128  int val8 ;
16129  int ecode8 = 0 ;
16130  octave_value_list _out;
16131  octave_value_list *_outp=&_out;
16132  octave_value _outv;
16133 
16134  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
16135  SWIG_fail;
16136  }
16137  ecode1 = SWIG_AsVal_double(args(0), &val1);
16138  if (!SWIG_IsOK(ecode1)) {
16139  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
16140  }
16141  arg1 = (PLFLT)(val1);
16142  ecode2 = SWIG_AsVal_double(args(1), &val2);
16143  if (!SWIG_IsOK(ecode2)) {
16144  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
16145  }
16146  arg2 = (PLFLT)(val2);
16147  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
16148  if (!SWIG_IsOK(res3)) {
16149  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
16150  }
16151  arg3 = (char *)(buf3);
16152  ecode4 = SWIG_AsVal_double(args(3), &val4);
16153  if (!SWIG_IsOK(ecode4)) {
16154  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
16155  }
16156  arg4 = (PLFLT)(val4);
16157  ecode5 = SWIG_AsVal_int(args(4), &val5);
16158  if (!SWIG_IsOK(ecode5)) {
16159  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
16160  }
16161  arg5 = (PLINT)(val5);
16162  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16163  if (!SWIG_IsOK(res6)) {
16164  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
16165  }
16166  arg6 = (char *)(buf6);
16167  ecode7 = SWIG_AsVal_double(args(6), &val7);
16168  if (!SWIG_IsOK(ecode7)) {
16169  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
16170  }
16171  arg7 = (PLFLT)(val7);
16172  ecode8 = SWIG_AsVal_int(args(7), &val8);
16173  if (!SWIG_IsOK(ecode8)) {
16174  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
16175  }
16176  arg8 = (PLINT)(val8);
16177  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
16178  _outv = octave_value();
16179  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16180  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16181  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16182  return _out;
16183 fail:
16184  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16185  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16186  return octave_value_list();
16187 }
16188 
16189 
16190 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
16191  PLINT arg1 ;
16192  PLFLT *arg2 = (PLFLT *) 0 ;
16193  PLFLT *arg3 = (PLFLT *) 0 ;
16194  PLINT arg4 ;
16195  Matrix temp1 ;
16196  Matrix temp3 ;
16197  int val4 ;
16198  int ecode4 = 0 ;
16199  octave_value_list _out;
16200  octave_value_list *_outp=&_out;
16201  octave_value _outv;
16202 
16203  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
16204  SWIG_fail;
16205  }
16206  {
16207  if ( _n_dims( args(0) ) > 1 )
16208  {
16209  error( "argument must be a scalar or vector" ); SWIG_fail;
16210  }
16211  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16212  temp1 = args(0).matrix_value();
16213  arg2 = &temp1( 0, 0 );
16214  }
16215  {
16216  if ( _n_dims( args(1) ) > 1 )
16217  {
16218  error( "argument must be a scalar or vector" ); SWIG_fail;
16219  }
16220  if ( _dim( args(1), 0 ) != Alen )
16221  {
16222  error( "argument vectors must be same length" ); SWIG_fail;
16223  }
16224  temp3 = args(1).matrix_value();
16225  arg3 = &temp3( 0, 0 );
16226  }
16227  ecode4 = SWIG_AsVal_int(args(2), &val4);
16228  if (!SWIG_IsOK(ecode4)) {
16229  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
16230  }
16231  arg4 = (PLINT)(val4);
16232  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16233  _outv = octave_value();
16234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16235  {
16236 
16237  }
16238  {
16239 
16240  }
16241  return _out;
16242 fail:
16243  {
16244 
16245  }
16246  {
16247 
16248  }
16249  return octave_value_list();
16250 }
16251 
16252 
16253 SWIG_DEFUN( plbtime, _wrap_plbtime, _wrap_plbtime_texinfo ) {
16254  PLINT *arg1 = (PLINT *) 0 ;
16255  PLINT *arg2 = (PLINT *) 0 ;
16256  PLINT *arg3 = (PLINT *) 0 ;
16257  PLINT *arg4 = (PLINT *) 0 ;
16258  PLINT *arg5 = (PLINT *) 0 ;
16259  PLFLT *arg6 = (PLFLT *) 0 ;
16260  PLFLT arg7 ;
16261  PLINT temp1 ;
16262  int res1 = SWIG_TMPOBJ ;
16263  PLINT temp2 ;
16264  int res2 = SWIG_TMPOBJ ;
16265  PLINT temp3 ;
16266  int res3 = SWIG_TMPOBJ ;
16267  PLINT temp4 ;
16268  int res4 = SWIG_TMPOBJ ;
16269  PLINT temp5 ;
16270  int res5 = SWIG_TMPOBJ ;
16271  PLFLT temp6 ;
16272  int res6 = SWIG_TMPOBJ ;
16273  double val7 ;
16274  int ecode7 = 0 ;
16275  octave_value_list _out;
16276  octave_value_list *_outp=&_out;
16277  octave_value _outv;
16278 
16279  arg1 = &temp1;
16280  arg2 = &temp2;
16281  arg3 = &temp3;
16282  arg4 = &temp4;
16283  arg5 = &temp5;
16284  arg6 = &temp6;
16285  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
16286  SWIG_fail;
16287  }
16288  ecode7 = SWIG_AsVal_double(args(0), &val7);
16289  if (!SWIG_IsOK(ecode7)) {
16290  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
16291  }
16292  arg7 = (PLFLT)(val7);
16293  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16294  _outv = octave_value();
16295  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16296  if (SWIG_IsTmpObj(res1)) {
16297  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16298  } else {
16299  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16300  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16301  }
16302  if (SWIG_IsTmpObj(res2)) {
16303  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16304  } else {
16305  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16306  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16307  }
16308  if (SWIG_IsTmpObj(res3)) {
16309  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16310  } else {
16311  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16312  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16313  }
16314  if (SWIG_IsTmpObj(res4)) {
16315  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16316  } else {
16317  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16318  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16319  }
16320  if (SWIG_IsTmpObj(res5)) {
16321  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16322  } else {
16323  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16324  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16325  }
16326  if (SWIG_IsTmpObj(res6)) {
16327  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
16328  } else {
16329  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16330  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
16331  }
16332  return _out;
16333 fail:
16334  return octave_value_list();
16335 }
16336 
16337 
16338 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
16339  octave_value_list _out;
16340  octave_value_list *_outp=&_out;
16341  octave_value _outv;
16342 
16343  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
16344  SWIG_fail;
16345  }
16346  plbop();
16347  _outv = octave_value();
16348  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16349  return _out;
16350 fail:
16351  return octave_value_list();
16352 }
16353 
16354 
16355 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
16356  char *arg1 = (char *) 0 ;
16357  PLFLT arg2 ;
16358  PLINT arg3 ;
16359  char *arg4 = (char *) 0 ;
16360  PLFLT arg5 ;
16361  PLINT arg6 ;
16362  int res1 ;
16363  char *buf1 = 0 ;
16364  int alloc1 = 0 ;
16365  double val2 ;
16366  int ecode2 = 0 ;
16367  int val3 ;
16368  int ecode3 = 0 ;
16369  int res4 ;
16370  char *buf4 = 0 ;
16371  int alloc4 = 0 ;
16372  double val5 ;
16373  int ecode5 = 0 ;
16374  int val6 ;
16375  int ecode6 = 0 ;
16376  octave_value_list _out;
16377  octave_value_list *_outp=&_out;
16378  octave_value _outv;
16379 
16380  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
16381  SWIG_fail;
16382  }
16383  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16384  if (!SWIG_IsOK(res1)) {
16385  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
16386  }
16387  arg1 = (char *)(buf1);
16388  ecode2 = SWIG_AsVal_double(args(1), &val2);
16389  if (!SWIG_IsOK(ecode2)) {
16390  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
16391  }
16392  arg2 = (PLFLT)(val2);
16393  ecode3 = SWIG_AsVal_int(args(2), &val3);
16394  if (!SWIG_IsOK(ecode3)) {
16395  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
16396  }
16397  arg3 = (PLINT)(val3);
16398  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
16399  if (!SWIG_IsOK(res4)) {
16400  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
16401  }
16402  arg4 = (char *)(buf4);
16403  ecode5 = SWIG_AsVal_double(args(4), &val5);
16404  if (!SWIG_IsOK(ecode5)) {
16405  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
16406  }
16407  arg5 = (PLFLT)(val5);
16408  ecode6 = SWIG_AsVal_int(args(5), &val6);
16409  if (!SWIG_IsOK(ecode6)) {
16410  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
16411  }
16412  arg6 = (PLINT)(val6);
16413  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
16414  _outv = octave_value();
16415  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16416  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16417  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16418  return _out;
16419 fail:
16420  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16421  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16422  return octave_value_list();
16423 }
16424 
16425 
16426 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
16427  char *arg1 = (char *) 0 ;
16428  char *arg2 = (char *) 0 ;
16429  PLFLT arg3 ;
16430  PLINT arg4 ;
16431  char *arg5 = (char *) 0 ;
16432  char *arg6 = (char *) 0 ;
16433  PLFLT arg7 ;
16434  PLINT arg8 ;
16435  char *arg9 = (char *) 0 ;
16436  char *arg10 = (char *) 0 ;
16437  PLFLT arg11 ;
16438  PLINT arg12 ;
16439  int res1 ;
16440  char *buf1 = 0 ;
16441  int alloc1 = 0 ;
16442  int res2 ;
16443  char *buf2 = 0 ;
16444  int alloc2 = 0 ;
16445  double val3 ;
16446  int ecode3 = 0 ;
16447  int val4 ;
16448  int ecode4 = 0 ;
16449  int res5 ;
16450  char *buf5 = 0 ;
16451  int alloc5 = 0 ;
16452  int res6 ;
16453  char *buf6 = 0 ;
16454  int alloc6 = 0 ;
16455  double val7 ;
16456  int ecode7 = 0 ;
16457  int val8 ;
16458  int ecode8 = 0 ;
16459  int res9 ;
16460  char *buf9 = 0 ;
16461  int alloc9 = 0 ;
16462  int res10 ;
16463  char *buf10 = 0 ;
16464  int alloc10 = 0 ;
16465  double val11 ;
16466  int ecode11 = 0 ;
16467  int val12 ;
16468  int ecode12 = 0 ;
16469  octave_value_list _out;
16470  octave_value_list *_outp=&_out;
16471  octave_value _outv;
16472 
16473  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
16474  SWIG_fail;
16475  }
16476  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16477  if (!SWIG_IsOK(res1)) {
16478  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
16479  }
16480  arg1 = (char *)(buf1);
16481  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
16482  if (!SWIG_IsOK(res2)) {
16483  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
16484  }
16485  arg2 = (char *)(buf2);
16486  ecode3 = SWIG_AsVal_double(args(2), &val3);
16487  if (!SWIG_IsOK(ecode3)) {
16488  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
16489  }
16490  arg3 = (PLFLT)(val3);
16491  ecode4 = SWIG_AsVal_int(args(3), &val4);
16492  if (!SWIG_IsOK(ecode4)) {
16493  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
16494  }
16495  arg4 = (PLINT)(val4);
16496  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16497  if (!SWIG_IsOK(res5)) {
16498  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
16499  }
16500  arg5 = (char *)(buf5);
16501  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16502  if (!SWIG_IsOK(res6)) {
16503  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
16504  }
16505  arg6 = (char *)(buf6);
16506  ecode7 = SWIG_AsVal_double(args(6), &val7);
16507  if (!SWIG_IsOK(ecode7)) {
16508  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
16509  }
16510  arg7 = (PLFLT)(val7);
16511  ecode8 = SWIG_AsVal_int(args(7), &val8);
16512  if (!SWIG_IsOK(ecode8)) {
16513  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
16514  }
16515  arg8 = (PLINT)(val8);
16516  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
16517  if (!SWIG_IsOK(res9)) {
16518  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
16519  }
16520  arg9 = (char *)(buf9);
16521  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
16522  if (!SWIG_IsOK(res10)) {
16523  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
16524  }
16525  arg10 = (char *)(buf10);
16526  ecode11 = SWIG_AsVal_double(args(10), &val11);
16527  if (!SWIG_IsOK(ecode11)) {
16528  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
16529  }
16530  arg11 = (PLFLT)(val11);
16531  ecode12 = SWIG_AsVal_int(args(11), &val12);
16532  if (!SWIG_IsOK(ecode12)) {
16533  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
16534  }
16535  arg12 = (PLINT)(val12);
16536  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);
16537  _outv = octave_value();
16538  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16539  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16540  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16541  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16542  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16543  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16544  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16545  return _out;
16546 fail:
16547  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16548  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16549  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16550  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16551  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16552  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16553  return octave_value_list();
16554 }
16555 
16556 
16557 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
16558  PLFLT arg1 ;
16559  PLFLT arg2 ;
16560  PLFLT *arg3 = (PLFLT *) 0 ;
16561  PLFLT *arg4 = (PLFLT *) 0 ;
16562  PLINT *arg5 = (PLINT *) 0 ;
16563  double val1 ;
16564  int ecode1 = 0 ;
16565  double val2 ;
16566  int ecode2 = 0 ;
16567  PLFLT temp3 ;
16568  int res3 = SWIG_TMPOBJ ;
16569  PLFLT temp4 ;
16570  int res4 = SWIG_TMPOBJ ;
16571  PLINT temp5 ;
16572  int res5 = SWIG_TMPOBJ ;
16573  octave_value_list _out;
16574  octave_value_list *_outp=&_out;
16575  octave_value _outv;
16576 
16577  arg3 = &temp3;
16578  arg4 = &temp4;
16579  arg5 = &temp5;
16580  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
16581  SWIG_fail;
16582  }
16583  ecode1 = SWIG_AsVal_double(args(0), &val1);
16584  if (!SWIG_IsOK(ecode1)) {
16585  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
16586  }
16587  arg1 = (PLFLT)(val1);
16588  ecode2 = SWIG_AsVal_double(args(1), &val2);
16589  if (!SWIG_IsOK(ecode2)) {
16590  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
16591  }
16592  arg2 = (PLFLT)(val2);
16593  plcalc_world(arg1,arg2,arg3,arg4,arg5);
16594  _outv = octave_value();
16595  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16596  if (SWIG_IsTmpObj(res3)) {
16597  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
16598  } else {
16599  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16600  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
16601  }
16602  if (SWIG_IsTmpObj(res4)) {
16603  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16604  } else {
16605  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16606  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16607  }
16608  if (SWIG_IsTmpObj(res5)) {
16609  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16610  } else {
16611  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16612  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16613  }
16614  return _out;
16615 fail:
16616  return octave_value_list();
16617 }
16618 
16619 
16620 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
16621  octave_value_list _out;
16622  octave_value_list *_outp=&_out;
16623  octave_value _outv;
16624 
16625  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
16626  SWIG_fail;
16627  }
16628  plclear();
16629  _outv = octave_value();
16630  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16631  return _out;
16632 fail:
16633  return octave_value_list();
16634 }
16635 
16636 
16637 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
16638  PLINT arg1 ;
16639  int val1 ;
16640  int ecode1 = 0 ;
16641  octave_value_list _out;
16642  octave_value_list *_outp=&_out;
16643  octave_value _outv;
16644 
16645  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
16646  SWIG_fail;
16647  }
16648  ecode1 = SWIG_AsVal_int(args(0), &val1);
16649  if (!SWIG_IsOK(ecode1)) {
16650  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
16651  }
16652  arg1 = (PLINT)(val1);
16653  plcol0(arg1);
16654  _outv = octave_value();
16655  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16656  return _out;
16657 fail:
16658  return octave_value_list();
16659 }
16660 
16661 
16662 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
16663  PLFLT arg1 ;
16664  double val1 ;
16665  int ecode1 = 0 ;
16666  octave_value_list _out;
16667  octave_value_list *_outp=&_out;
16668  octave_value _outv;
16669 
16670  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
16671  SWIG_fail;
16672  }
16673  ecode1 = SWIG_AsVal_double(args(0), &val1);
16674  if (!SWIG_IsOK(ecode1)) {
16675  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
16676  }
16677  arg1 = (PLFLT)(val1);
16678  plcol1(arg1);
16679  _outv = octave_value();
16680  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16681  return _out;
16682 fail:
16683  return octave_value_list();
16684 }
16685 
16686 
16687 SWIG_DEFUN( plconfigtime, _wrap_plconfigtime, _wrap_plconfigtime_texinfo ) {
16688  PLFLT arg1 ;
16689  PLFLT arg2 ;
16690  PLFLT arg3 ;
16691  PLINT arg4 ;
16692  PLBOOL arg5 ;
16693  PLINT arg6 ;
16694  PLINT arg7 ;
16695  PLINT arg8 ;
16696  PLINT arg9 ;
16697  PLINT arg10 ;
16698  PLFLT arg11 ;
16699  double val1 ;
16700  int ecode1 = 0 ;
16701  double val2 ;
16702  int ecode2 = 0 ;
16703  double val3 ;
16704  int ecode3 = 0 ;
16705  int val4 ;
16706  int ecode4 = 0 ;
16707  int val5 ;
16708  int ecode5 = 0 ;
16709  int val6 ;
16710  int ecode6 = 0 ;
16711  int val7 ;
16712  int ecode7 = 0 ;
16713  int val8 ;
16714  int ecode8 = 0 ;
16715  int val9 ;
16716  int ecode9 = 0 ;
16717  int val10 ;
16718  int ecode10 = 0 ;
16719  double val11 ;
16720  int ecode11 = 0 ;
16721  octave_value_list _out;
16722  octave_value_list *_outp=&_out;
16723  octave_value _outv;
16724 
16725  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
16726  SWIG_fail;
16727  }
16728  ecode1 = SWIG_AsVal_double(args(0), &val1);
16729  if (!SWIG_IsOK(ecode1)) {
16730  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
16731  }
16732  arg1 = (PLFLT)(val1);
16733  ecode2 = SWIG_AsVal_double(args(1), &val2);
16734  if (!SWIG_IsOK(ecode2)) {
16735  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
16736  }
16737  arg2 = (PLFLT)(val2);
16738  ecode3 = SWIG_AsVal_double(args(2), &val3);
16739  if (!SWIG_IsOK(ecode3)) {
16740  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
16741  }
16742  arg3 = (PLFLT)(val3);
16743  ecode4 = SWIG_AsVal_int(args(3), &val4);
16744  if (!SWIG_IsOK(ecode4)) {
16745  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
16746  }
16747  arg4 = (PLINT)(val4);
16748  ecode5 = SWIG_AsVal_int(args(4), &val5);
16749  if (!SWIG_IsOK(ecode5)) {
16750  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
16751  }
16752  arg5 = (PLBOOL)(val5);
16753  ecode6 = SWIG_AsVal_int(args(5), &val6);
16754  if (!SWIG_IsOK(ecode6)) {
16755  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
16756  }
16757  arg6 = (PLINT)(val6);
16758  ecode7 = SWIG_AsVal_int(args(6), &val7);
16759  if (!SWIG_IsOK(ecode7)) {
16760  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
16761  }
16762  arg7 = (PLINT)(val7);
16763  ecode8 = SWIG_AsVal_int(args(7), &val8);
16764  if (!SWIG_IsOK(ecode8)) {
16765  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
16766  }
16767  arg8 = (PLINT)(val8);
16768  ecode9 = SWIG_AsVal_int(args(8), &val9);
16769  if (!SWIG_IsOK(ecode9)) {
16770  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
16771  }
16772  arg9 = (PLINT)(val9);
16773  ecode10 = SWIG_AsVal_int(args(9), &val10);
16774  if (!SWIG_IsOK(ecode10)) {
16775  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
16776  }
16777  arg10 = (PLINT)(val10);
16778  ecode11 = SWIG_AsVal_double(args(10), &val11);
16779  if (!SWIG_IsOK(ecode11)) {
16780  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
16781  }
16782  arg11 = (PLFLT)(val11);
16783  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
16784  _outv = octave_value();
16785  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16786  return _out;
16787 fail:
16788  return octave_value_list();
16789 }
16790 
16791 
16792 SWIG_DEFUN( plctime, _wrap_plctime, _wrap_plctime_texinfo ) {
16793  PLINT arg1 ;
16794  PLINT arg2 ;
16795  PLINT arg3 ;
16796  PLINT arg4 ;
16797  PLINT arg5 ;
16798  PLFLT arg6 ;
16799  PLFLT *arg7 = (PLFLT *) 0 ;
16800  int val1 ;
16801  int ecode1 = 0 ;
16802  int val2 ;
16803  int ecode2 = 0 ;
16804  int val3 ;
16805  int ecode3 = 0 ;
16806  int val4 ;
16807  int ecode4 = 0 ;
16808  int val5 ;
16809  int ecode5 = 0 ;
16810  double val6 ;
16811  int ecode6 = 0 ;
16812  PLFLT temp7 ;
16813  int res7 = SWIG_TMPOBJ ;
16814  octave_value_list _out;
16815  octave_value_list *_outp=&_out;
16816  octave_value _outv;
16817 
16818  arg7 = &temp7;
16819  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
16820  SWIG_fail;
16821  }
16822  ecode1 = SWIG_AsVal_int(args(0), &val1);
16823  if (!SWIG_IsOK(ecode1)) {
16824  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
16825  }
16826  arg1 = (PLINT)(val1);
16827  ecode2 = SWIG_AsVal_int(args(1), &val2);
16828  if (!SWIG_IsOK(ecode2)) {
16829  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
16830  }
16831  arg2 = (PLINT)(val2);
16832  ecode3 = SWIG_AsVal_int(args(2), &val3);
16833  if (!SWIG_IsOK(ecode3)) {
16834  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
16835  }
16836  arg3 = (PLINT)(val3);
16837  ecode4 = SWIG_AsVal_int(args(3), &val4);
16838  if (!SWIG_IsOK(ecode4)) {
16839  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
16840  }
16841  arg4 = (PLINT)(val4);
16842  ecode5 = SWIG_AsVal_int(args(4), &val5);
16843  if (!SWIG_IsOK(ecode5)) {
16844  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
16845  }
16846  arg5 = (PLINT)(val5);
16847  ecode6 = SWIG_AsVal_double(args(5), &val6);
16848  if (!SWIG_IsOK(ecode6)) {
16849  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
16850  }
16851  arg6 = (PLFLT)(val6);
16852  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16853  _outv = octave_value();
16854  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16855  if (SWIG_IsTmpObj(res7)) {
16856  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
16857  } else {
16858  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16859  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
16860  }
16861  return _out;
16862 fail:
16863  return octave_value_list();
16864 }
16865 
16866 
16867 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
16868  PLINT arg1 ;
16869  PLBOOL arg2 ;
16870  int val1 ;
16871  int ecode1 = 0 ;
16872  int val2 ;
16873  int ecode2 = 0 ;
16874  octave_value_list _out;
16875  octave_value_list *_outp=&_out;
16876  octave_value _outv;
16877 
16878  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
16879  SWIG_fail;
16880  }
16881  ecode1 = SWIG_AsVal_int(args(0), &val1);
16882  if (!SWIG_IsOK(ecode1)) {
16883  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
16884  }
16885  arg1 = (PLINT)(val1);
16886  ecode2 = SWIG_AsVal_int(args(1), &val2);
16887  if (!SWIG_IsOK(ecode2)) {
16888  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
16889  }
16890  arg2 = (PLBOOL)(val2);
16891  plcpstrm(arg1,arg2);
16892  _outv = octave_value();
16893  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16894  return _out;
16895 fail:
16896  return octave_value_list();
16897 }
16898 
16899 
16900 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
16901  octave_value_list _out;
16902  octave_value_list *_outp=&_out;
16903  octave_value _outv;
16904 
16905  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
16906  SWIG_fail;
16907  }
16908  plend();
16909  _outv = octave_value();
16910  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16911  return _out;
16912 fail:
16913  return octave_value_list();
16914 }
16915 
16916 
16917 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
16918  octave_value_list _out;
16919  octave_value_list *_outp=&_out;
16920  octave_value _outv;
16921 
16922  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
16923  SWIG_fail;
16924  }
16925  plend1();
16926  _outv = octave_value();
16927  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16928  return _out;
16929 fail:
16930  return octave_value_list();
16931 }
16932 
16933 
16934 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
16935  PLFLT arg1 ;
16936  PLFLT arg2 ;
16937  PLFLT arg3 ;
16938  PLFLT arg4 ;
16939  PLINT arg5 ;
16940  PLINT arg6 ;
16941  double val1 ;
16942  int ecode1 = 0 ;
16943  double val2 ;
16944  int ecode2 = 0 ;
16945  double val3 ;
16946  int ecode3 = 0 ;
16947  double val4 ;
16948  int ecode4 = 0 ;
16949  int val5 ;
16950  int ecode5 = 0 ;
16951  int val6 ;
16952  int ecode6 = 0 ;
16953  octave_value_list _out;
16954  octave_value_list *_outp=&_out;
16955  octave_value _outv;
16956 
16957  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
16958  SWIG_fail;
16959  }
16960  ecode1 = SWIG_AsVal_double(args(0), &val1);
16961  if (!SWIG_IsOK(ecode1)) {
16962  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
16963  }
16964  arg1 = (PLFLT)(val1);
16965  ecode2 = SWIG_AsVal_double(args(1), &val2);
16966  if (!SWIG_IsOK(ecode2)) {
16967  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
16968  }
16969  arg2 = (PLFLT)(val2);
16970  ecode3 = SWIG_AsVal_double(args(2), &val3);
16971  if (!SWIG_IsOK(ecode3)) {
16972  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
16973  }
16974  arg3 = (PLFLT)(val3);
16975  ecode4 = SWIG_AsVal_double(args(3), &val4);
16976  if (!SWIG_IsOK(ecode4)) {
16977  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
16978  }
16979  arg4 = (PLFLT)(val4);
16980  ecode5 = SWIG_AsVal_int(args(4), &val5);
16981  if (!SWIG_IsOK(ecode5)) {
16982  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
16983  }
16984  arg5 = (PLINT)(val5);
16985  ecode6 = SWIG_AsVal_int(args(5), &val6);
16986  if (!SWIG_IsOK(ecode6)) {
16987  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
16988  }
16989  arg6 = (PLINT)(val6);
16990  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
16991  _outv = octave_value();
16992  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16993  return _out;
16994 fail:
16995  return octave_value_list();
16996 }
16997 
16998 
16999 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
17000  PLFLT arg1 ;
17001  PLFLT arg2 ;
17002  PLFLT arg3 ;
17003  PLFLT arg4 ;
17004  PLINT arg5 ;
17005  PLINT arg6 ;
17006  double val1 ;
17007  int ecode1 = 0 ;
17008  double val2 ;
17009  int ecode2 = 0 ;
17010  double val3 ;
17011  int ecode3 = 0 ;
17012  double val4 ;
17013  int ecode4 = 0 ;
17014  int val5 ;
17015  int ecode5 = 0 ;
17016  int val6 ;
17017  int ecode6 = 0 ;
17018  octave_value_list _out;
17019  octave_value_list *_outp=&_out;
17020  octave_value _outv;
17021 
17022  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
17023  SWIG_fail;
17024  }
17025  ecode1 = SWIG_AsVal_double(args(0), &val1);
17026  if (!SWIG_IsOK(ecode1)) {
17027  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
17028  }
17029  arg1 = (PLFLT)(val1);
17030  ecode2 = SWIG_AsVal_double(args(1), &val2);
17031  if (!SWIG_IsOK(ecode2)) {
17032  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
17033  }
17034  arg2 = (PLFLT)(val2);
17035  ecode3 = SWIG_AsVal_double(args(2), &val3);
17036  if (!SWIG_IsOK(ecode3)) {
17037  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
17038  }
17039  arg3 = (PLFLT)(val3);
17040  ecode4 = SWIG_AsVal_double(args(3), &val4);
17041  if (!SWIG_IsOK(ecode4)) {
17042  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
17043  }
17044  arg4 = (PLFLT)(val4);
17045  ecode5 = SWIG_AsVal_int(args(4), &val5);
17046  if (!SWIG_IsOK(ecode5)) {
17047  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
17048  }
17049  arg5 = (PLINT)(val5);
17050  ecode6 = SWIG_AsVal_int(args(5), &val6);
17051  if (!SWIG_IsOK(ecode6)) {
17052  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
17053  }
17054  arg6 = (PLINT)(val6);
17055  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17056  _outv = octave_value();
17057  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17058  return _out;
17059 fail:
17060  return octave_value_list();
17061 }
17062 
17063 
17064 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
17065  octave_value_list _out;
17066  octave_value_list *_outp=&_out;
17067  octave_value _outv;
17068 
17069  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
17070  SWIG_fail;
17071  }
17072  pleop();
17073  _outv = octave_value();
17074  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17075  return _out;
17076 fail:
17077  return octave_value_list();
17078 }
17079 
17080 
17081 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
17082  PLINT arg1 ;
17083  PLFLT *arg2 = (PLFLT *) 0 ;
17084  PLFLT *arg3 = (PLFLT *) 0 ;
17085  PLFLT *arg4 = (PLFLT *) 0 ;
17086  Matrix temp1 ;
17087  Matrix temp3 ;
17088  Matrix temp4 ;
17089  octave_value_list _out;
17090  octave_value_list *_outp=&_out;
17091  octave_value _outv;
17092 
17093  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
17094  SWIG_fail;
17095  }
17096  {
17097  if ( _n_dims( args(0) ) > 1 )
17098  {
17099  error( "argument must be a scalar or vector" ); SWIG_fail;
17100  }
17101  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17102  temp1 = args(0).matrix_value();
17103  arg2 = &temp1( 0, 0 );
17104  }
17105  {
17106  if ( _n_dims( args(1) ) > 1 )
17107  {
17108  error( "argument must be a scalar or vector" ); SWIG_fail;
17109  }
17110  if ( _dim( args(1), 0 ) != Alen )
17111  {
17112  error( "argument vectors must be same length" ); SWIG_fail;
17113  }
17114  temp3 = args(1).matrix_value();
17115  arg3 = &temp3( 0, 0 );
17116  }
17117  {
17118  if ( _n_dims( args(2) ) > 1 )
17119  {
17120  error( "argument must be a scalar or vector" ); SWIG_fail;
17121  }
17122  if ( _dim( args(2), 0 ) != Alen )
17123  {
17124  error( "argument vectors must be same length" ); SWIG_fail;
17125  }
17126  temp4 = args(2).matrix_value();
17127  arg4 = &temp4( 0, 0 );
17128  }
17129  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17130  _outv = octave_value();
17131  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17132  {
17133 
17134  }
17135  {
17136 
17137  }
17138  {
17139 
17140  }
17141  return _out;
17142 fail:
17143  {
17144 
17145  }
17146  {
17147 
17148  }
17149  {
17150 
17151  }
17152  return octave_value_list();
17153 }
17154 
17155 
17156 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
17157  PLINT arg1 ;
17158  PLFLT *arg2 = (PLFLT *) 0 ;
17159  PLFLT *arg3 = (PLFLT *) 0 ;
17160  PLFLT *arg4 = (PLFLT *) 0 ;
17161  Matrix temp1 ;
17162  Matrix temp3 ;
17163  Matrix temp4 ;
17164  octave_value_list _out;
17165  octave_value_list *_outp=&_out;
17166  octave_value _outv;
17167 
17168  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
17169  SWIG_fail;
17170  }
17171  {
17172  if ( _n_dims( args(0) ) > 1 )
17173  {
17174  error( "argument must be a scalar or vector" ); SWIG_fail;
17175  }
17176  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17177  temp1 = args(0).matrix_value();
17178  arg2 = &temp1( 0, 0 );
17179  }
17180  {
17181  if ( _n_dims( args(1) ) > 1 )
17182  {
17183  error( "argument must be a scalar or vector" ); SWIG_fail;
17184  }
17185  if ( _dim( args(1), 0 ) != Alen )
17186  {
17187  error( "argument vectors must be same length" ); SWIG_fail;
17188  }
17189  temp3 = args(1).matrix_value();
17190  arg3 = &temp3( 0, 0 );
17191  }
17192  {
17193  if ( _n_dims( args(2) ) > 1 )
17194  {
17195  error( "argument must be a scalar or vector" ); SWIG_fail;
17196  }
17197  if ( _dim( args(2), 0 ) != Alen )
17198  {
17199  error( "argument vectors must be same length" ); SWIG_fail;
17200  }
17201  temp4 = args(2).matrix_value();
17202  arg4 = &temp4( 0, 0 );
17203  }
17204  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17205  _outv = octave_value();
17206  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17207  {
17208 
17209  }
17210  {
17211 
17212  }
17213  {
17214 
17215  }
17216  return _out;
17217 fail:
17218  {
17219 
17220  }
17221  {
17222 
17223  }
17224  {
17225 
17226  }
17227  return octave_value_list();
17228 }
17229 
17230 
17231 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
17232  octave_value_list _out;
17233  octave_value_list *_outp=&_out;
17234  octave_value _outv;
17235 
17236  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
17237  SWIG_fail;
17238  }
17239  plfamadv();
17240  _outv = octave_value();
17241  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17242  return _out;
17243 fail:
17244  return octave_value_list();
17245 }
17246 
17247 
17248 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
17249  PLINT arg1 ;
17250  PLFLT *arg2 = (PLFLT *) 0 ;
17251  PLFLT *arg3 = (PLFLT *) 0 ;
17252  Matrix temp1 ;
17253  Matrix temp3 ;
17254  octave_value_list _out;
17255  octave_value_list *_outp=&_out;
17256  octave_value _outv;
17257 
17258  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
17259  SWIG_fail;
17260  }
17261  {
17262  if ( _n_dims( args(0) ) > 1 )
17263  {
17264  error( "argument must be a scalar or vector" ); SWIG_fail;
17265  }
17266  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17267  temp1 = args(0).matrix_value();
17268  arg2 = &temp1( 0, 0 );
17269  }
17270  {
17271  if ( _n_dims( args(1) ) > 1 )
17272  {
17273  error( "argument must be a scalar or vector" ); SWIG_fail;
17274  }
17275  if ( _dim( args(1), 0 ) != Alen )
17276  {
17277  error( "argument vectors must be same length" ); SWIG_fail;
17278  }
17279  temp3 = args(1).matrix_value();
17280  arg3 = &temp3( 0, 0 );
17281  }
17282  plfill(arg1,(double const *)arg2,(double const *)arg3);
17283  _outv = octave_value();
17284  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17285  {
17286 
17287  }
17288  {
17289 
17290  }
17291  return _out;
17292 fail:
17293  {
17294 
17295  }
17296  {
17297 
17298  }
17299  return octave_value_list();
17300 }
17301 
17302 
17303 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
17304  PLINT arg1 ;
17305  PLFLT *arg2 = (PLFLT *) 0 ;
17306  PLFLT *arg3 = (PLFLT *) 0 ;
17307  PLFLT *arg4 = (PLFLT *) 0 ;
17308  Matrix temp1 ;
17309  Matrix temp3 ;
17310  Matrix temp4 ;
17311  octave_value_list _out;
17312  octave_value_list *_outp=&_out;
17313  octave_value _outv;
17314 
17315  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
17316  SWIG_fail;
17317  }
17318  {
17319  if ( _n_dims( args(0) ) > 1 )
17320  {
17321  error( "argument must be a scalar or vector" ); SWIG_fail;
17322  }
17323  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17324  temp1 = args(0).matrix_value();
17325  arg2 = &temp1( 0, 0 );
17326  }
17327  {
17328  if ( _n_dims( args(1) ) > 1 )
17329  {
17330  error( "argument must be a scalar or vector" ); SWIG_fail;
17331  }
17332  if ( _dim( args(1), 0 ) != Alen )
17333  {
17334  error( "argument vectors must be same length" ); SWIG_fail;
17335  }
17336  temp3 = args(1).matrix_value();
17337  arg3 = &temp3( 0, 0 );
17338  }
17339  {
17340  if ( _n_dims( args(2) ) > 1 )
17341  {
17342  error( "argument must be a scalar or vector" ); SWIG_fail;
17343  }
17344  if ( _dim( args(2), 0 ) != Alen )
17345  {
17346  error( "argument vectors must be same length" ); SWIG_fail;
17347  }
17348  temp4 = args(2).matrix_value();
17349  arg4 = &temp4( 0, 0 );
17350  }
17351  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17352  _outv = octave_value();
17353  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17354  {
17355 
17356  }
17357  {
17358 
17359  }
17360  {
17361 
17362  }
17363  return _out;
17364 fail:
17365  {
17366 
17367  }
17368  {
17369 
17370  }
17371  {
17372 
17373  }
17374  return octave_value_list();
17375 }
17376 
17377 
17378 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
17379  PLINT arg1 ;
17380  PLFLT *arg2 = (PLFLT *) 0 ;
17381  PLFLT *arg3 = (PLFLT *) 0 ;
17382  PLFLT arg4 ;
17383  Matrix temp1 ;
17384  Matrix temp3 ;
17385  double val4 ;
17386  int ecode4 = 0 ;
17387  octave_value_list _out;
17388  octave_value_list *_outp=&_out;
17389  octave_value _outv;
17390 
17391  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
17392  SWIG_fail;
17393  }
17394  {
17395  if ( _n_dims( args(0) ) > 1 )
17396  {
17397  error( "argument must be a scalar or vector" ); SWIG_fail;
17398  }
17399  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17400  temp1 = args(0).matrix_value();
17401  arg2 = &temp1( 0, 0 );
17402  }
17403  {
17404  if ( _n_dims( args(1) ) > 1 )
17405  {
17406  error( "argument must be a scalar or vector" ); SWIG_fail;
17407  }
17408  if ( _dim( args(1), 0 ) != Alen )
17409  {
17410  error( "argument vectors must be same length" ); SWIG_fail;
17411  }
17412  temp3 = args(1).matrix_value();
17413  arg3 = &temp3( 0, 0 );
17414  }
17415  ecode4 = SWIG_AsVal_double(args(2), &val4);
17416  if (!SWIG_IsOK(ecode4)) {
17417  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
17418  }
17419  arg4 = (PLFLT)(val4);
17420  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
17421  _outv = octave_value();
17422  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17423  {
17424 
17425  }
17426  {
17427 
17428  }
17429  return _out;
17430 fail:
17431  {
17432 
17433  }
17434  {
17435 
17436  }
17437  return octave_value_list();
17438 }
17439 
17440 
17441 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
17442  octave_value_list _out;
17443  octave_value_list *_outp=&_out;
17444  octave_value _outv;
17445 
17446  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
17447  SWIG_fail;
17448  }
17449  plflush();
17450  _outv = octave_value();
17451  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17452  return _out;
17453 fail:
17454  return octave_value_list();
17455 }
17456 
17457 
17458 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
17459  PLINT arg1 ;
17460  int val1 ;
17461  int ecode1 = 0 ;
17462  octave_value_list _out;
17463  octave_value_list *_outp=&_out;
17464  octave_value _outv;
17465 
17466  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
17467  SWIG_fail;
17468  }
17469  ecode1 = SWIG_AsVal_int(args(0), &val1);
17470  if (!SWIG_IsOK(ecode1)) {
17471  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
17472  }
17473  arg1 = (PLINT)(val1);
17474  plfont(arg1);
17475  _outv = octave_value();
17476  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17477  return _out;
17478 fail:
17479  return octave_value_list();
17480 }
17481 
17482 
17483 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
17484  PLINT arg1 ;
17485  int val1 ;
17486  int ecode1 = 0 ;
17487  octave_value_list _out;
17488  octave_value_list *_outp=&_out;
17489  octave_value _outv;
17490 
17491  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
17492  SWIG_fail;
17493  }
17494  ecode1 = SWIG_AsVal_int(args(0), &val1);
17495  if (!SWIG_IsOK(ecode1)) {
17496  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
17497  }
17498  arg1 = (PLINT)(val1);
17499  plfontld(arg1);
17500  _outv = octave_value();
17501  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17502  return _out;
17503 fail:
17504  return octave_value_list();
17505 }
17506 
17507 
17508 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
17509  PLFLT *arg1 = (PLFLT *) 0 ;
17510  PLFLT *arg2 = (PLFLT *) 0 ;
17511  PLFLT temp1 ;
17512  int res1 = SWIG_TMPOBJ ;
17513  PLFLT temp2 ;
17514  int res2 = SWIG_TMPOBJ ;
17515  octave_value_list _out;
17516  octave_value_list *_outp=&_out;
17517  octave_value _outv;
17518 
17519  arg1 = &temp1;
17520  arg2 = &temp2;
17521  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
17522  SWIG_fail;
17523  }
17524  plgchr(arg1,arg2);
17525  _outv = octave_value();
17526  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17527  if (SWIG_IsTmpObj(res1)) {
17528  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17529  } else {
17530  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17531  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17532  }
17533  if (SWIG_IsTmpObj(res2)) {
17534  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17535  } else {
17536  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17537  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17538  }
17539  return _out;
17540 fail:
17541  return octave_value_list();
17542 }
17543 
17544 
17545 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
17546  PLINT arg1 ;
17547  PLINT *arg2 = (PLINT *) 0 ;
17548  PLINT *arg3 = (PLINT *) 0 ;
17549  PLINT *arg4 = (PLINT *) 0 ;
17550  int val1 ;
17551  int ecode1 = 0 ;
17552  PLINT temp2 ;
17553  int res2 = SWIG_TMPOBJ ;
17554  PLINT temp3 ;
17555  int res3 = SWIG_TMPOBJ ;
17556  PLINT temp4 ;
17557  int res4 = SWIG_TMPOBJ ;
17558  octave_value_list _out;
17559  octave_value_list *_outp=&_out;
17560  octave_value _outv;
17561 
17562  arg2 = &temp2;
17563  arg3 = &temp3;
17564  arg4 = &temp4;
17565  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
17566  SWIG_fail;
17567  }
17568  ecode1 = SWIG_AsVal_int(args(0), &val1);
17569  if (!SWIG_IsOK(ecode1)) {
17570  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
17571  }
17572  arg1 = (PLINT)(val1);
17573  plgcol0(arg1,arg2,arg3,arg4);
17574  _outv = octave_value();
17575  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17576  if (SWIG_IsTmpObj(res2)) {
17577  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17578  } else {
17579  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17580  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17581  }
17582  if (SWIG_IsTmpObj(res3)) {
17583  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17584  } else {
17585  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17586  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17587  }
17588  if (SWIG_IsTmpObj(res4)) {
17589  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17590  } else {
17591  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17592  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17593  }
17594  return _out;
17595 fail:
17596  return octave_value_list();
17597 }
17598 
17599 
17600 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
17601  PLINT arg1 ;
17602  PLINT *arg2 = (PLINT *) 0 ;
17603  PLINT *arg3 = (PLINT *) 0 ;
17604  PLINT *arg4 = (PLINT *) 0 ;
17605  PLFLT *arg5 = (PLFLT *) 0 ;
17606  int val1 ;
17607  int ecode1 = 0 ;
17608  PLINT temp2 ;
17609  int res2 = SWIG_TMPOBJ ;
17610  PLINT temp3 ;
17611  int res3 = SWIG_TMPOBJ ;
17612  PLINT temp4 ;
17613  int res4 = SWIG_TMPOBJ ;
17614  PLFLT temp5 ;
17615  int res5 = SWIG_TMPOBJ ;
17616  octave_value_list _out;
17617  octave_value_list *_outp=&_out;
17618  octave_value _outv;
17619 
17620  arg2 = &temp2;
17621  arg3 = &temp3;
17622  arg4 = &temp4;
17623  arg5 = &temp5;
17624  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
17625  SWIG_fail;
17626  }
17627  ecode1 = SWIG_AsVal_int(args(0), &val1);
17628  if (!SWIG_IsOK(ecode1)) {
17629  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
17630  }
17631  arg1 = (PLINT)(val1);
17632  plgcol0a(arg1,arg2,arg3,arg4,arg5);
17633  _outv = octave_value();
17634  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17635  if (SWIG_IsTmpObj(res2)) {
17636  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17637  } else {
17638  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17639  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17640  }
17641  if (SWIG_IsTmpObj(res3)) {
17642  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17643  } else {
17644  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17645  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17646  }
17647  if (SWIG_IsTmpObj(res4)) {
17648  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17649  } else {
17650  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17651  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17652  }
17653  if (SWIG_IsTmpObj(res5)) {
17654  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17655  } else {
17656  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17657  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17658  }
17659  return _out;
17660 fail:
17661  return octave_value_list();
17662 }
17663 
17664 
17665 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
17666  PLINT *arg1 = (PLINT *) 0 ;
17667  PLINT *arg2 = (PLINT *) 0 ;
17668  PLINT *arg3 = (PLINT *) 0 ;
17669  PLINT temp1 ;
17670  int res1 = SWIG_TMPOBJ ;
17671  PLINT temp2 ;
17672  int res2 = SWIG_TMPOBJ ;
17673  PLINT temp3 ;
17674  int res3 = SWIG_TMPOBJ ;
17675  octave_value_list _out;
17676  octave_value_list *_outp=&_out;
17677  octave_value _outv;
17678 
17679  arg1 = &temp1;
17680  arg2 = &temp2;
17681  arg3 = &temp3;
17682  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
17683  SWIG_fail;
17684  }
17685  plgcolbg(arg1,arg2,arg3);
17686  _outv = octave_value();
17687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17688  if (SWIG_IsTmpObj(res1)) {
17689  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17690  } else {
17691  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17692  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17693  }
17694  if (SWIG_IsTmpObj(res2)) {
17695  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17696  } else {
17697  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17698  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17699  }
17700  if (SWIG_IsTmpObj(res3)) {
17701  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17702  } else {
17703  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17704  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17705  }
17706  return _out;
17707 fail:
17708  return octave_value_list();
17709 }
17710 
17711 
17712 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
17713  PLINT *arg1 = (PLINT *) 0 ;
17714  PLINT *arg2 = (PLINT *) 0 ;
17715  PLINT *arg3 = (PLINT *) 0 ;
17716  PLFLT *arg4 = (PLFLT *) 0 ;
17717  PLINT temp1 ;
17718  int res1 = SWIG_TMPOBJ ;
17719  PLINT temp2 ;
17720  int res2 = SWIG_TMPOBJ ;
17721  PLINT temp3 ;
17722  int res3 = SWIG_TMPOBJ ;
17723  PLFLT temp4 ;
17724  int res4 = SWIG_TMPOBJ ;
17725  octave_value_list _out;
17726  octave_value_list *_outp=&_out;
17727  octave_value _outv;
17728 
17729  arg1 = &temp1;
17730  arg2 = &temp2;
17731  arg3 = &temp3;
17732  arg4 = &temp4;
17733  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
17734  SWIG_fail;
17735  }
17736  plgcolbga(arg1,arg2,arg3,arg4);
17737  _outv = octave_value();
17738  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17739  if (SWIG_IsTmpObj(res1)) {
17740  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17741  } else {
17742  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17743  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17744  }
17745  if (SWIG_IsTmpObj(res2)) {
17746  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17747  } else {
17748  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17749  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17750  }
17751  if (SWIG_IsTmpObj(res3)) {
17752  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17753  } else {
17754  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17755  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17756  }
17757  if (SWIG_IsTmpObj(res4)) {
17758  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17759  } else {
17760  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17761  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17762  }
17763  return _out;
17764 fail:
17765  return octave_value_list();
17766 }
17767 
17768 
17769 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
17770  PLINT *arg1 = (PLINT *) 0 ;
17771  PLINT temp1 ;
17772  int res1 = SWIG_TMPOBJ ;
17773  octave_value_list _out;
17774  octave_value_list *_outp=&_out;
17775  octave_value _outv;
17776 
17777  arg1 = &temp1;
17778  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
17779  SWIG_fail;
17780  }
17781  plgcompression(arg1);
17782  _outv = octave_value();
17783  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17784  if (SWIG_IsTmpObj(res1)) {
17785  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17786  } else {
17787  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17788  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17789  }
17790  return _out;
17791 fail:
17792  return octave_value_list();
17793 }
17794 
17795 
17796 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
17797  char *arg1 = (char *) 0 ;
17798  octave_value_list retval1 ;
17799  octave_value_list _out;
17800  octave_value_list *_outp=&_out;
17801  octave_value _outv;
17802 
17803  {
17804  // Check if version >= 3.4.0
17805 # if OCTAVE_API_VERSION_NUMBER < 45
17806  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
17807 # else
17808  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
17809 # endif
17810  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
17811  }
17812  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
17813  SWIG_fail;
17814  }
17815  plgdev(arg1);
17816  _outv = octave_value();
17817  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17818  {
17819  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
17820  }
17821  return _out;
17822 fail:
17823  return octave_value_list();
17824 }
17825 
17826 
17827 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
17828  PLFLT *arg1 = (PLFLT *) 0 ;
17829  PLFLT *arg2 = (PLFLT *) 0 ;
17830  PLFLT *arg3 = (PLFLT *) 0 ;
17831  PLFLT *arg4 = (PLFLT *) 0 ;
17832  PLFLT temp1 ;
17833  int res1 = SWIG_TMPOBJ ;
17834  PLFLT temp2 ;
17835  int res2 = SWIG_TMPOBJ ;
17836  PLFLT temp3 ;
17837  int res3 = SWIG_TMPOBJ ;
17838  PLFLT temp4 ;
17839  int res4 = SWIG_TMPOBJ ;
17840  octave_value_list _out;
17841  octave_value_list *_outp=&_out;
17842  octave_value _outv;
17843 
17844  arg1 = &temp1;
17845  arg2 = &temp2;
17846  arg3 = &temp3;
17847  arg4 = &temp4;
17848  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
17849  SWIG_fail;
17850  }
17851  plgdidev(arg1,arg2,arg3,arg4);
17852  _outv = octave_value();
17853  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17854  if (SWIG_IsTmpObj(res1)) {
17855  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17856  } else {
17857  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17858  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17859  }
17860  if (SWIG_IsTmpObj(res2)) {
17861  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17862  } else {
17863  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17864  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17865  }
17866  if (SWIG_IsTmpObj(res3)) {
17867  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17868  } else {
17869  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17870  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17871  }
17872  if (SWIG_IsTmpObj(res4)) {
17873  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17874  } else {
17875  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17876  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17877  }
17878  return _out;
17879 fail:
17880  return octave_value_list();
17881 }
17882 
17883 
17884 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
17885  PLFLT *arg1 = (PLFLT *) 0 ;
17886  PLFLT temp1 ;
17887  int res1 = SWIG_TMPOBJ ;
17888  octave_value_list _out;
17889  octave_value_list *_outp=&_out;
17890  octave_value _outv;
17891 
17892  arg1 = &temp1;
17893  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
17894  SWIG_fail;
17895  }
17896  plgdiori(arg1);
17897  _outv = octave_value();
17898  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17899  if (SWIG_IsTmpObj(res1)) {
17900  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17901  } else {
17902  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17903  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17904  }
17905  return _out;
17906 fail:
17907  return octave_value_list();
17908 }
17909 
17910 
17911 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
17912  PLFLT *arg1 = (PLFLT *) 0 ;
17913  PLFLT *arg2 = (PLFLT *) 0 ;
17914  PLFLT *arg3 = (PLFLT *) 0 ;
17915  PLFLT *arg4 = (PLFLT *) 0 ;
17916  PLFLT temp1 ;
17917  int res1 = SWIG_TMPOBJ ;
17918  PLFLT temp2 ;
17919  int res2 = SWIG_TMPOBJ ;
17920  PLFLT temp3 ;
17921  int res3 = SWIG_TMPOBJ ;
17922  PLFLT temp4 ;
17923  int res4 = SWIG_TMPOBJ ;
17924  octave_value_list _out;
17925  octave_value_list *_outp=&_out;
17926  octave_value _outv;
17927 
17928  arg1 = &temp1;
17929  arg2 = &temp2;
17930  arg3 = &temp3;
17931  arg4 = &temp4;
17932  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
17933  SWIG_fail;
17934  }
17935  plgdiplt(arg1,arg2,arg3,arg4);
17936  _outv = octave_value();
17937  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17938  if (SWIG_IsTmpObj(res1)) {
17939  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17940  } else {
17941  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17942  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17943  }
17944  if (SWIG_IsTmpObj(res2)) {
17945  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17946  } else {
17947  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17948  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17949  }
17950  if (SWIG_IsTmpObj(res3)) {
17951  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17952  } else {
17953  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17954  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17955  }
17956  if (SWIG_IsTmpObj(res4)) {
17957  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17958  } else {
17959  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17960  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17961  }
17962  return _out;
17963 fail:
17964  return octave_value_list();
17965 }
17966 
17967 
17968 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
17969  PLINT *arg1 = (PLINT *) 0 ;
17970  PLINT *arg2 = (PLINT *) 0 ;
17971  PLINT *arg3 = (PLINT *) 0 ;
17972  PLINT temp1 ;
17973  int res1 = SWIG_TMPOBJ ;
17974  PLINT temp2 ;
17975  int res2 = SWIG_TMPOBJ ;
17976  PLINT temp3 ;
17977  int res3 = SWIG_TMPOBJ ;
17978  octave_value_list _out;
17979  octave_value_list *_outp=&_out;
17980  octave_value _outv;
17981 
17982  arg1 = &temp1;
17983  arg2 = &temp2;
17984  arg3 = &temp3;
17985  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
17986  SWIG_fail;
17987  }
17988  plgfam(arg1,arg2,arg3);
17989  _outv = octave_value();
17990  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17991  if (SWIG_IsTmpObj(res1)) {
17992  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17993  } else {
17994  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17995  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17996  }
17997  if (SWIG_IsTmpObj(res2)) {
17998  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17999  } else {
18000  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18001  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18002  }
18003  if (SWIG_IsTmpObj(res3)) {
18004  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18005  } else {
18006  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18007  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18008  }
18009  return _out;
18010 fail:
18011  return octave_value_list();
18012 }
18013 
18014 
18015 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
18016  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
18017  PLUNICODE temp1 ;
18018  int res1 = SWIG_TMPOBJ ;
18019  octave_value_list _out;
18020  octave_value_list *_outp=&_out;
18021  octave_value _outv;
18022 
18023  arg1 = &temp1;
18024  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
18025  SWIG_fail;
18026  }
18027  plgfci(arg1);
18028  _outv = octave_value();
18029  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18030  if (SWIG_IsTmpObj(res1)) {
18031  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
18032  } else {
18033  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18034  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
18035  }
18036  return _out;
18037 fail:
18038  return octave_value_list();
18039 }
18040 
18041 
18042 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
18043  char *arg1 = (char *) 0 ;
18044  octave_value_list retval1 ;
18045  octave_value_list _out;
18046  octave_value_list *_outp=&_out;
18047  octave_value _outv;
18048 
18049  {
18050  // Check if version >= 3.4.0
18051 # if OCTAVE_API_VERSION_NUMBER < 45
18052  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
18053 # else
18054  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
18055 # endif
18056  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
18057  }
18058  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
18059  SWIG_fail;
18060  }
18061  plgfnam(arg1);
18062  _outv = octave_value();
18063  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18064  {
18065  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18066  }
18067  return _out;
18068 fail:
18069  return octave_value_list();
18070 }
18071 
18072 
18073 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
18074  PLINT *arg1 = (PLINT *) 0 ;
18075  PLINT *arg2 = (PLINT *) 0 ;
18076  PLINT *arg3 = (PLINT *) 0 ;
18077  PLINT temp1 ;
18078  int res1 = SWIG_TMPOBJ ;
18079  PLINT temp2 ;
18080  int res2 = SWIG_TMPOBJ ;
18081  PLINT temp3 ;
18082  int res3 = SWIG_TMPOBJ ;
18083  octave_value_list _out;
18084  octave_value_list *_outp=&_out;
18085  octave_value _outv;
18086 
18087  arg1 = &temp1;
18088  arg2 = &temp2;
18089  arg3 = &temp3;
18090  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
18091  SWIG_fail;
18092  }
18093  plgfont(arg1,arg2,arg3);
18094  _outv = octave_value();
18095  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18096  if (SWIG_IsTmpObj(res1)) {
18097  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18098  } else {
18099  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18100  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18101  }
18102  if (SWIG_IsTmpObj(res2)) {
18103  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18104  } else {
18105  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18106  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18107  }
18108  if (SWIG_IsTmpObj(res3)) {
18109  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18110  } else {
18111  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18112  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18113  }
18114  return _out;
18115 fail:
18116  return octave_value_list();
18117 }
18118 
18119 
18120 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
18121  PLINT *arg1 = (PLINT *) 0 ;
18122  PLINT temp1 ;
18123  int res1 = SWIG_TMPOBJ ;
18124  octave_value_list _out;
18125  octave_value_list *_outp=&_out;
18126  octave_value _outv;
18127 
18128  arg1 = &temp1;
18129  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
18130  SWIG_fail;
18131  }
18132  plglevel(arg1);
18133  _outv = octave_value();
18134  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18135  if (SWIG_IsTmpObj(res1)) {
18136  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18137  } else {
18138  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18139  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18140  }
18141  return _out;
18142 fail:
18143  return octave_value_list();
18144 }
18145 
18146 
18147 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
18148  PLFLT *arg1 = (PLFLT *) 0 ;
18149  PLFLT *arg2 = (PLFLT *) 0 ;
18150  PLINT *arg3 = (PLINT *) 0 ;
18151  PLINT *arg4 = (PLINT *) 0 ;
18152  PLINT *arg5 = (PLINT *) 0 ;
18153  PLINT *arg6 = (PLINT *) 0 ;
18154  PLFLT temp1 ;
18155  int res1 = SWIG_TMPOBJ ;
18156  PLFLT temp2 ;
18157  int res2 = SWIG_TMPOBJ ;
18158  PLINT temp3 ;
18159  int res3 = SWIG_TMPOBJ ;
18160  PLINT temp4 ;
18161  int res4 = SWIG_TMPOBJ ;
18162  PLINT temp5 ;
18163  int res5 = SWIG_TMPOBJ ;
18164  PLINT temp6 ;
18165  int res6 = SWIG_TMPOBJ ;
18166  octave_value_list _out;
18167  octave_value_list *_outp=&_out;
18168  octave_value _outv;
18169 
18170  arg1 = &temp1;
18171  arg2 = &temp2;
18172  arg3 = &temp3;
18173  arg4 = &temp4;
18174  arg5 = &temp5;
18175  arg6 = &temp6;
18176  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
18177  SWIG_fail;
18178  }
18179  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18180  _outv = octave_value();
18181  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18182  if (SWIG_IsTmpObj(res1)) {
18183  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18184  } else {
18185  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18186  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18187  }
18188  if (SWIG_IsTmpObj(res2)) {
18189  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18190  } else {
18191  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18192  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18193  }
18194  if (SWIG_IsTmpObj(res3)) {
18195  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18196  } else {
18197  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18198  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18199  }
18200  if (SWIG_IsTmpObj(res4)) {
18201  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18202  } else {
18203  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18204  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18205  }
18206  if (SWIG_IsTmpObj(res5)) {
18207  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
18208  } else {
18209  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18210  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18211  }
18212  if (SWIG_IsTmpObj(res6)) {
18213  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
18214  } else {
18215  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18216  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
18217  }
18218  return _out;
18219 fail:
18220  return octave_value_list();
18221 }
18222 
18223 
18224 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
18225  octave_value_list _out;
18226  octave_value_list *_outp=&_out;
18227  octave_value _outv;
18228 
18229  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
18230  SWIG_fail;
18231  }
18232  plgra();
18233  _outv = octave_value();
18234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18235  return _out;
18236 fail:
18237  return octave_value_list();
18238 }
18239 
18240 
18241 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
18242  PLFLT *arg1 = (PLFLT *) 0 ;
18243  PLFLT *arg2 = (PLFLT *) 0 ;
18244  PLFLT *arg3 = (PLFLT *) 0 ;
18245  PLFLT *arg4 = (PLFLT *) 0 ;
18246  PLFLT temp1 ;
18247  int res1 = SWIG_TMPOBJ ;
18248  PLFLT temp2 ;
18249  int res2 = SWIG_TMPOBJ ;
18250  PLFLT temp3 ;
18251  int res3 = SWIG_TMPOBJ ;
18252  PLFLT temp4 ;
18253  int res4 = SWIG_TMPOBJ ;
18254  octave_value_list _out;
18255  octave_value_list *_outp=&_out;
18256  octave_value _outv;
18257 
18258  arg1 = &temp1;
18259  arg2 = &temp2;
18260  arg3 = &temp3;
18261  arg4 = &temp4;
18262  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
18263  SWIG_fail;
18264  }
18265  plgspa(arg1,arg2,arg3,arg4);
18266  _outv = octave_value();
18267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18268  if (SWIG_IsTmpObj(res1)) {
18269  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18270  } else {
18271  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18272  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18273  }
18274  if (SWIG_IsTmpObj(res2)) {
18275  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18276  } else {
18277  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18278  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18279  }
18280  if (SWIG_IsTmpObj(res3)) {
18281  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18282  } else {
18283  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18284  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18285  }
18286  if (SWIG_IsTmpObj(res4)) {
18287  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18288  } else {
18289  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18290  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18291  }
18292  return _out;
18293 fail:
18294  return octave_value_list();
18295 }
18296 
18297 
18298 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
18299  PLINT *arg1 = (PLINT *) 0 ;
18300  PLINT temp1 ;
18301  int res1 = SWIG_TMPOBJ ;
18302  octave_value_list _out;
18303  octave_value_list *_outp=&_out;
18304  octave_value _outv;
18305 
18306  arg1 = &temp1;
18307  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
18308  SWIG_fail;
18309  }
18310  plgstrm(arg1);
18311  _outv = octave_value();
18312  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18313  if (SWIG_IsTmpObj(res1)) {
18314  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18315  } else {
18316  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18317  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18318  }
18319  return _out;
18320 fail:
18321  return octave_value_list();
18322 }
18323 
18324 
18325 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
18326  char *arg1 = (char *) 0 ;
18327  octave_value_list retval1 ;
18328  octave_value_list _out;
18329  octave_value_list *_outp=&_out;
18330  octave_value _outv;
18331 
18332  {
18333  // Check if version >= 3.4.0
18334 # if OCTAVE_API_VERSION_NUMBER < 45
18335  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
18336 # else
18337  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
18338 # endif
18339  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
18340  }
18341  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
18342  SWIG_fail;
18343  }
18344  plgver(arg1);
18345  _outv = octave_value();
18346  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18347  {
18348  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18349  }
18350  return _out;
18351 fail:
18352  return octave_value_list();
18353 }
18354 
18355 
18356 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
18357  PLFLT *arg1 = (PLFLT *) 0 ;
18358  PLFLT *arg2 = (PLFLT *) 0 ;
18359  PLFLT *arg3 = (PLFLT *) 0 ;
18360  PLFLT *arg4 = (PLFLT *) 0 ;
18361  PLFLT temp1 ;
18362  int res1 = SWIG_TMPOBJ ;
18363  PLFLT temp2 ;
18364  int res2 = SWIG_TMPOBJ ;
18365  PLFLT temp3 ;
18366  int res3 = SWIG_TMPOBJ ;
18367  PLFLT temp4 ;
18368  int res4 = SWIG_TMPOBJ ;
18369  octave_value_list _out;
18370  octave_value_list *_outp=&_out;
18371  octave_value _outv;
18372 
18373  arg1 = &temp1;
18374  arg2 = &temp2;
18375  arg3 = &temp3;
18376  arg4 = &temp4;
18377  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
18378  SWIG_fail;
18379  }
18380  plgvpd(arg1,arg2,arg3,arg4);
18381  _outv = octave_value();
18382  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18383  if (SWIG_IsTmpObj(res1)) {
18384  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18385  } else {
18386  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18387  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18388  }
18389  if (SWIG_IsTmpObj(res2)) {
18390  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18391  } else {
18392  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18393  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18394  }
18395  if (SWIG_IsTmpObj(res3)) {
18396  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18397  } else {
18398  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18399  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18400  }
18401  if (SWIG_IsTmpObj(res4)) {
18402  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18403  } else {
18404  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18405  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18406  }
18407  return _out;
18408 fail:
18409  return octave_value_list();
18410 }
18411 
18412 
18413 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
18414  PLFLT *arg1 = (PLFLT *) 0 ;
18415  PLFLT *arg2 = (PLFLT *) 0 ;
18416  PLFLT *arg3 = (PLFLT *) 0 ;
18417  PLFLT *arg4 = (PLFLT *) 0 ;
18418  PLFLT temp1 ;
18419  int res1 = SWIG_TMPOBJ ;
18420  PLFLT temp2 ;
18421  int res2 = SWIG_TMPOBJ ;
18422  PLFLT temp3 ;
18423  int res3 = SWIG_TMPOBJ ;
18424  PLFLT temp4 ;
18425  int res4 = SWIG_TMPOBJ ;
18426  octave_value_list _out;
18427  octave_value_list *_outp=&_out;
18428  octave_value _outv;
18429 
18430  arg1 = &temp1;
18431  arg2 = &temp2;
18432  arg3 = &temp3;
18433  arg4 = &temp4;
18434  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
18435  SWIG_fail;
18436  }
18437  plgvpw(arg1,arg2,arg3,arg4);
18438  _outv = octave_value();
18439  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18440  if (SWIG_IsTmpObj(res1)) {
18441  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18442  } else {
18443  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18444  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18445  }
18446  if (SWIG_IsTmpObj(res2)) {
18447  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18448  } else {
18449  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18450  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18451  }
18452  if (SWIG_IsTmpObj(res3)) {
18453  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18454  } else {
18455  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18456  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18457  }
18458  if (SWIG_IsTmpObj(res4)) {
18459  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18460  } else {
18461  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18462  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18463  }
18464  return _out;
18465 fail:
18466  return octave_value_list();
18467 }
18468 
18469 
18470 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
18471  PLINT *arg1 = (PLINT *) 0 ;
18472  PLINT *arg2 = (PLINT *) 0 ;
18473  PLINT temp1 ;
18474  int res1 = SWIG_TMPOBJ ;
18475  PLINT temp2 ;
18476  int res2 = SWIG_TMPOBJ ;
18477  octave_value_list _out;
18478  octave_value_list *_outp=&_out;
18479  octave_value _outv;
18480 
18481  arg1 = &temp1;
18482  arg2 = &temp2;
18483  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
18484  SWIG_fail;
18485  }
18486  plgxax(arg1,arg2);
18487  _outv = octave_value();
18488  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18489  if (SWIG_IsTmpObj(res1)) {
18490  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18491  } else {
18492  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18493  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18494  }
18495  if (SWIG_IsTmpObj(res2)) {
18496  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18497  } else {
18498  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18499  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18500  }
18501  return _out;
18502 fail:
18503  return octave_value_list();
18504 }
18505 
18506 
18507 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
18508  PLINT *arg1 = (PLINT *) 0 ;
18509  PLINT *arg2 = (PLINT *) 0 ;
18510  PLINT temp1 ;
18511  int res1 = SWIG_TMPOBJ ;
18512  PLINT temp2 ;
18513  int res2 = SWIG_TMPOBJ ;
18514  octave_value_list _out;
18515  octave_value_list *_outp=&_out;
18516  octave_value _outv;
18517 
18518  arg1 = &temp1;
18519  arg2 = &temp2;
18520  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
18521  SWIG_fail;
18522  }
18523  plgyax(arg1,arg2);
18524  _outv = octave_value();
18525  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18526  if (SWIG_IsTmpObj(res1)) {
18527  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18528  } else {
18529  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18530  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18531  }
18532  if (SWIG_IsTmpObj(res2)) {
18533  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18534  } else {
18535  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18536  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18537  }
18538  return _out;
18539 fail:
18540  return octave_value_list();
18541 }
18542 
18543 
18544 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
18545  PLINT *arg1 = (PLINT *) 0 ;
18546  PLINT *arg2 = (PLINT *) 0 ;
18547  PLINT temp1 ;
18548  int res1 = SWIG_TMPOBJ ;
18549  PLINT temp2 ;
18550  int res2 = SWIG_TMPOBJ ;
18551  octave_value_list _out;
18552  octave_value_list *_outp=&_out;
18553  octave_value _outv;
18554 
18555  arg1 = &temp1;
18556  arg2 = &temp2;
18557  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
18558  SWIG_fail;
18559  }
18560  plgzax(arg1,arg2);
18561  _outv = octave_value();
18562  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18563  if (SWIG_IsTmpObj(res1)) {
18564  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18565  } else {
18566  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18567  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18568  }
18569  if (SWIG_IsTmpObj(res2)) {
18570  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18571  } else {
18572  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18573  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18574  }
18575  return _out;
18576 fail:
18577  return octave_value_list();
18578 }
18579 
18580 
18581 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
18582  PLINT arg1 ;
18583  PLFLT *arg2 = (PLFLT *) 0 ;
18584  PLFLT arg3 ;
18585  PLFLT arg4 ;
18586  PLINT arg5 ;
18587  PLINT arg6 ;
18588  Matrix temp1 ;
18589  double val3 ;
18590  int ecode3 = 0 ;
18591  double val4 ;
18592  int ecode4 = 0 ;
18593  int val5 ;
18594  int ecode5 = 0 ;
18595  int val6 ;
18596  int ecode6 = 0 ;
18597  octave_value_list _out;
18598  octave_value_list *_outp=&_out;
18599  octave_value _outv;
18600 
18601  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
18602  SWIG_fail;
18603  }
18604  {
18605  if ( _n_dims( args(0) ) > 1 )
18606  {
18607  error( "argument must be a scalar or vector" ); SWIG_fail;
18608  }
18609  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18610  temp1 = args(0).matrix_value();
18611  arg2 = &temp1( 0, 0 );
18612  }
18613  ecode3 = SWIG_AsVal_double(args(1), &val3);
18614  if (!SWIG_IsOK(ecode3)) {
18615  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
18616  }
18617  arg3 = (PLFLT)(val3);
18618  ecode4 = SWIG_AsVal_double(args(2), &val4);
18619  if (!SWIG_IsOK(ecode4)) {
18620  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
18621  }
18622  arg4 = (PLFLT)(val4);
18623  ecode5 = SWIG_AsVal_int(args(3), &val5);
18624  if (!SWIG_IsOK(ecode5)) {
18625  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
18626  }
18627  arg5 = (PLINT)(val5);
18628  ecode6 = SWIG_AsVal_int(args(4), &val6);
18629  if (!SWIG_IsOK(ecode6)) {
18630  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
18631  }
18632  arg6 = (PLINT)(val6);
18633  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
18634  _outv = octave_value();
18635  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18636  {
18637 
18638  }
18639  return _out;
18640 fail:
18641  {
18642 
18643  }
18644  return octave_value_list();
18645 }
18646 
18647 
18648 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
18649  PLFLT arg1 ;
18650  PLFLT arg2 ;
18651  PLFLT arg3 ;
18652  PLFLT *arg4 = (PLFLT *) 0 ;
18653  PLFLT *arg5 = (PLFLT *) 0 ;
18654  PLFLT *arg6 = (PLFLT *) 0 ;
18655  double val1 ;
18656  int ecode1 = 0 ;
18657  double val2 ;
18658  int ecode2 = 0 ;
18659  double val3 ;
18660  int ecode3 = 0 ;
18661  PLFLT temp4 ;
18662  int res4 = SWIG_TMPOBJ ;
18663  PLFLT temp5 ;
18664  int res5 = SWIG_TMPOBJ ;
18665  PLFLT temp6 ;
18666  int res6 = SWIG_TMPOBJ ;
18667  octave_value_list _out;
18668  octave_value_list *_outp=&_out;
18669  octave_value _outv;
18670 
18671  arg4 = &temp4;
18672  arg5 = &temp5;
18673  arg6 = &temp6;
18674  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
18675  SWIG_fail;
18676  }
18677  ecode1 = SWIG_AsVal_double(args(0), &val1);
18678  if (!SWIG_IsOK(ecode1)) {
18679  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
18680  }
18681  arg1 = (PLFLT)(val1);
18682  ecode2 = SWIG_AsVal_double(args(1), &val2);
18683  if (!SWIG_IsOK(ecode2)) {
18684  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
18685  }
18686  arg2 = (PLFLT)(val2);
18687  ecode3 = SWIG_AsVal_double(args(2), &val3);
18688  if (!SWIG_IsOK(ecode3)) {
18689  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
18690  }
18691  arg3 = (PLFLT)(val3);
18692  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
18693  _outv = octave_value();
18694  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18695  if (SWIG_IsTmpObj(res4)) {
18696  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18697  } else {
18698  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18699  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18700  }
18701  if (SWIG_IsTmpObj(res5)) {
18702  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
18703  } else {
18704  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18705  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
18706  }
18707  if (SWIG_IsTmpObj(res6)) {
18708  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
18709  } else {
18710  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18711  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
18712  }
18713  return _out;
18714 fail:
18715  return octave_value_list();
18716 }
18717 
18718 
18719 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
18720  octave_value_list _out;
18721  octave_value_list *_outp=&_out;
18722  octave_value _outv;
18723 
18724  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
18725  SWIG_fail;
18726  }
18727  plinit();
18728  _outv = octave_value();
18729  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18730  return _out;
18731 fail:
18732  return octave_value_list();
18733 }
18734 
18735 
18736 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
18737  PLFLT arg1 ;
18738  PLFLT arg2 ;
18739  PLFLT arg3 ;
18740  PLFLT arg4 ;
18741  double val1 ;
18742  int ecode1 = 0 ;
18743  double val2 ;
18744  int ecode2 = 0 ;
18745  double val3 ;
18746  int ecode3 = 0 ;
18747  double val4 ;
18748  int ecode4 = 0 ;
18749  octave_value_list _out;
18750  octave_value_list *_outp=&_out;
18751  octave_value _outv;
18752 
18753  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
18754  SWIG_fail;
18755  }
18756  ecode1 = SWIG_AsVal_double(args(0), &val1);
18757  if (!SWIG_IsOK(ecode1)) {
18758  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
18759  }
18760  arg1 = (PLFLT)(val1);
18761  ecode2 = SWIG_AsVal_double(args(1), &val2);
18762  if (!SWIG_IsOK(ecode2)) {
18763  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
18764  }
18765  arg2 = (PLFLT)(val2);
18766  ecode3 = SWIG_AsVal_double(args(2), &val3);
18767  if (!SWIG_IsOK(ecode3)) {
18768  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
18769  }
18770  arg3 = (PLFLT)(val3);
18771  ecode4 = SWIG_AsVal_double(args(3), &val4);
18772  if (!SWIG_IsOK(ecode4)) {
18773  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
18774  }
18775  arg4 = (PLFLT)(val4);
18776  pljoin(arg1,arg2,arg3,arg4);
18777  _outv = octave_value();
18778  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18779  return _out;
18780 fail:
18781  return octave_value_list();
18782 }
18783 
18784 
18785 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
18786  char *arg1 = (char *) 0 ;
18787  char *arg2 = (char *) 0 ;
18788  char *arg3 = (char *) 0 ;
18789  int res1 ;
18790  char *buf1 = 0 ;
18791  int alloc1 = 0 ;
18792  int res2 ;
18793  char *buf2 = 0 ;
18794  int alloc2 = 0 ;
18795  int res3 ;
18796  char *buf3 = 0 ;
18797  int alloc3 = 0 ;
18798  octave_value_list _out;
18799  octave_value_list *_outp=&_out;
18800  octave_value _outv;
18801 
18802  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
18803  SWIG_fail;
18804  }
18805  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18806  if (!SWIG_IsOK(res1)) {
18807  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
18808  }
18809  arg1 = (char *)(buf1);
18810  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
18811  if (!SWIG_IsOK(res2)) {
18812  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
18813  }
18814  arg2 = (char *)(buf2);
18815  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
18816  if (!SWIG_IsOK(res3)) {
18817  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
18818  }
18819  arg3 = (char *)(buf3);
18820  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
18821  _outv = octave_value();
18822  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18823  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18824  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18825  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18826  return _out;
18827 fail:
18828  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18829  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18830  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
18831  return octave_value_list();
18832 }
18833 
18834 
18835 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
18836  PLFLT *arg1 = (PLFLT *) 0 ;
18837  PLFLT *arg2 = (PLFLT *) 0 ;
18838  PLINT arg3 ;
18839  PLINT arg4 ;
18840  PLFLT arg5 ;
18841  PLFLT arg6 ;
18842  PLFLT arg7 ;
18843  PLINT arg8 ;
18844  PLINT arg9 ;
18845  PLINT arg10 ;
18846  PLINT arg11 ;
18847  PLINT arg12 ;
18848  PLINT arg13 ;
18849  PLINT *arg14 = (PLINT *) 0 ;
18850  PLFLT arg15 ;
18851  PLFLT arg16 ;
18852  PLFLT arg17 ;
18853  PLFLT arg18 ;
18854  PLINT *arg19 = (PLINT *) 0 ;
18855  char **arg20 = (char **) 0 ;
18856  PLINT *arg21 = (PLINT *) 0 ;
18857  PLINT *arg22 = (PLINT *) 0 ;
18858  PLFLT *arg23 = (PLFLT *) 0 ;
18859  PLFLT *arg24 = (PLFLT *) 0 ;
18860  PLINT *arg25 = (PLINT *) 0 ;
18861  PLINT *arg26 = (PLINT *) 0 ;
18862  PLFLT *arg27 = (PLFLT *) 0 ;
18863  PLINT *arg28 = (PLINT *) 0 ;
18864  PLFLT *arg29 = (PLFLT *) 0 ;
18865  PLINT *arg30 = (PLINT *) 0 ;
18866  char **arg31 = (char **) 0 ;
18867  PLFLT temp1 ;
18868  int res1 = SWIG_TMPOBJ ;
18869  PLFLT temp2 ;
18870  int res2 = SWIG_TMPOBJ ;
18871  int val3 ;
18872  int ecode3 = 0 ;
18873  int val4 ;
18874  int ecode4 = 0 ;
18875  double val5 ;
18876  int ecode5 = 0 ;
18877  double val6 ;
18878  int ecode6 = 0 ;
18879  double val7 ;
18880  int ecode7 = 0 ;
18881  int val8 ;
18882  int ecode8 = 0 ;
18883  int val9 ;
18884  int ecode9 = 0 ;
18885  int val10 ;
18886  int ecode10 = 0 ;
18887  int val11 ;
18888  int ecode11 = 0 ;
18889  int val12 ;
18890  int ecode12 = 0 ;
18891  Matrix temp13 ;
18892  double val15 ;
18893  int ecode15 = 0 ;
18894  double val16 ;
18895  int ecode16 = 0 ;
18896  double val17 ;
18897  int ecode17 = 0 ;
18898  double val18 ;
18899  int ecode18 = 0 ;
18900  Matrix temp19 ;
18901  Matrix temp21 ;
18902  Matrix temp22 ;
18903  Matrix temp23 ;
18904  Matrix temp24 ;
18905  Matrix temp25 ;
18906  Matrix temp26 ;
18907  Matrix temp27 ;
18908  Matrix temp28 ;
18909  Matrix temp29 ;
18910  Matrix temp30 ;
18911  octave_value_list _out;
18912  octave_value_list *_outp=&_out;
18913  octave_value _outv;
18914 
18915  arg1 = &temp1;
18916  arg2 = &temp2;
18917  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
18918  SWIG_fail;
18919  }
18920  ecode3 = SWIG_AsVal_int(args(0), &val3);
18921  if (!SWIG_IsOK(ecode3)) {
18922  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
18923  }
18924  arg3 = (PLINT)(val3);
18925  ecode4 = SWIG_AsVal_int(args(1), &val4);
18926  if (!SWIG_IsOK(ecode4)) {
18927  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
18928  }
18929  arg4 = (PLINT)(val4);
18930  ecode5 = SWIG_AsVal_double(args(2), &val5);
18931  if (!SWIG_IsOK(ecode5)) {
18932  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
18933  }
18934  arg5 = (PLFLT)(val5);
18935  ecode6 = SWIG_AsVal_double(args(3), &val6);
18936  if (!SWIG_IsOK(ecode6)) {
18937  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
18938  }
18939  arg6 = (PLFLT)(val6);
18940  ecode7 = SWIG_AsVal_double(args(4), &val7);
18941  if (!SWIG_IsOK(ecode7)) {
18942  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
18943  }
18944  arg7 = (PLFLT)(val7);
18945  ecode8 = SWIG_AsVal_int(args(5), &val8);
18946  if (!SWIG_IsOK(ecode8)) {
18947  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
18948  }
18949  arg8 = (PLINT)(val8);
18950  ecode9 = SWIG_AsVal_int(args(6), &val9);
18951  if (!SWIG_IsOK(ecode9)) {
18952  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
18953  }
18954  arg9 = (PLINT)(val9);
18955  ecode10 = SWIG_AsVal_int(args(7), &val10);
18956  if (!SWIG_IsOK(ecode10)) {
18957  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
18958  }
18959  arg10 = (PLINT)(val10);
18960  ecode11 = SWIG_AsVal_int(args(8), &val11);
18961  if (!SWIG_IsOK(ecode11)) {
18962  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
18963  }
18964  arg11 = (PLINT)(val11);
18965  ecode12 = SWIG_AsVal_int(args(9), &val12);
18966  if (!SWIG_IsOK(ecode12)) {
18967  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
18968  }
18969  arg12 = (PLINT)(val12);
18970  {
18971  if ( _n_dims( args(10) ) > 1 )
18972  {
18973  error( "argument must be a scalar or vector" ); SWIG_fail;
18974  }
18975  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
18976  arg14 = new PLINT[Alen];
18977  temp13 = args(10).matrix_value();
18978  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
18979  }
18980  ecode15 = SWIG_AsVal_double(args(11), &val15);
18981  if (!SWIG_IsOK(ecode15)) {
18982  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
18983  }
18984  arg15 = (PLFLT)(val15);
18985  ecode16 = SWIG_AsVal_double(args(12), &val16);
18986  if (!SWIG_IsOK(ecode16)) {
18987  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
18988  }
18989  arg16 = (PLFLT)(val16);
18990  ecode17 = SWIG_AsVal_double(args(13), &val17);
18991  if (!SWIG_IsOK(ecode17)) {
18992  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
18993  }
18994  arg17 = (PLFLT)(val17);
18995  ecode18 = SWIG_AsVal_double(args(14), &val18);
18996  if (!SWIG_IsOK(ecode18)) {
18997  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
18998  }
18999  arg18 = (PLFLT)(val18);
19000  {
19001  if ( _n_dims( args(15) ) > 1 )
19002  {
19003  error( "argument must be a scalar or vector" ); SWIG_fail;
19004  }
19005  if ( _dim( args(15), 0 ) != Alen )
19006  {
19007  error( "argument vectors must be same length" ); SWIG_fail;
19008  }
19009  temp19 = args(15).matrix_value();
19010  arg19 = new PLINT[Alen];
19011  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
19012  }
19013  {
19014  charMatrix temp_matrix;
19015  Cell temp_cell;
19016  char *tmp_cstring;
19017  std::string str;
19018  size_t max_length = 0, non_blank_length;
19019  int i, ifcell;
19020  if ( _n_dims( args(16) ) > 2 )
19021  {
19022  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19023  }
19024  if ( !args(16).is_empty() )
19025  {
19026  if ( _dim( args(16), 0 ) != Alen )
19027  {
19028  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19029  }
19030  arg20 = new char*[Alen];
19031  ifcell = args(16).is_cell();
19032  if ( ifcell )
19033  {
19034  temp_cell = args(16).cell_value();
19035  }
19036  else
19037  {
19038  temp_matrix = args(16).char_matrix_value();
19039  // Allow one extra space for null termination.
19040  max_length = _dim( args(16), 1 ) + 1;
19041  }
19042 
19043  for ( i = 0; i < Alen; i++ )
19044  {
19045  // Must copy string to "permanent" location because the string
19046  // location corresponding to tmp_cstring gets
19047  // overwritten for each iteration of loop.
19048  if ( ifcell )
19049  {
19050  if ( temp_cell.elem( i ).is_string() )
19051  {
19052  str = temp_cell.elem( i ).string_value();
19053  // leave room for null termination.
19054  max_length = str.size() + 1;
19055  tmp_cstring = (char *) str.c_str();
19056  }
19057  else
19058  {
19059  // Use null string if user attempts to pass a cell array
19060  // with a non-string element (likely an empty element
19061  // since that should be allowed by the PLplot interface
19062  // if that element is going to be unused).
19063  // leave room for null termination.
19064  max_length = 1;
19065  tmp_cstring = (char *) "";
19066  }
19067  }
19068  else
19069  {
19070  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
19071  }
19072  arg20[i] = new char[max_length];
19073  strncpy( arg20[i], tmp_cstring, max_length - 1 );
19074  arg20[i][max_length - 1] = '\0';
19075  // All the trailing blank crapola should not be needed for
19076  // string cell arrays.
19077  if ( !ifcell )
19078  {
19079  // remove trailing-blank padding that is used by the
19080  // charMatrix class to insure all strings in a given
19081  // charMatrix instance have the same length.
19082  // This transformation also removes legitimate trailing
19083  // blanks but there is nothing we can do about that
19084  // for the charMatrix class.
19085 
19086  // Look for trailing nulls first (just in case, although that
19087  // shouldn't happen if charMatrix implemented as documented)
19088  // before looking for trailing blanks.
19089  non_blank_length = max_length - 2;
19090  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
19091  {
19092  non_blank_length--;
19093  }
19094  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
19095  {
19096  non_blank_length--;
19097  }
19098  arg20[i][non_blank_length + 1] = '\0';
19099  }
19100  }
19101  }
19102  else
19103  {
19104  arg20 = NULL;
19105  }
19106  }
19107  {
19108  if ( _n_dims( args(17) ) > 1 )
19109  {
19110  error( "argument must be a scalar or vector" ); SWIG_fail;
19111  }
19112  if ( !args(17).is_empty() )
19113  {
19114  if ( _dim( args(17), 0 ) != Alen )
19115  {
19116  error( "argument vectors must be same length" ); SWIG_fail;
19117  }
19118  temp21 = args(17).matrix_value();
19119  arg21 = new PLINT[Alen];
19120  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
19121  }
19122  else
19123  {
19124  arg21 = NULL;
19125  }
19126  }
19127  {
19128  if ( _n_dims( args(18) ) > 1 )
19129  {
19130  error( "argument must be a scalar or vector" ); SWIG_fail;
19131  }
19132  if ( !args(18).is_empty() )
19133  {
19134  if ( _dim( args(18), 0 ) != Alen )
19135  {
19136  error( "argument vectors must be same length" ); SWIG_fail;
19137  }
19138  temp22 = args(18).matrix_value();
19139  arg22 = new PLINT[Alen];
19140  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
19141  }
19142  else
19143  {
19144  arg22 = NULL;
19145  }
19146  }
19147  {
19148  if ( _n_dims( args(19) ) > 1 )
19149  {
19150  error( "argument must be a scalar or vector" ); SWIG_fail;
19151  }
19152  if ( !args(19).is_empty() )
19153  {
19154  if ( _dim( args(19), 0 ) != Alen )
19155  {
19156  error( "argument vectors must be same length" ); SWIG_fail;
19157  }
19158  temp23 = args(19).matrix_value();
19159  arg23 = &temp23( 0, 0 );
19160  }
19161  else
19162  {
19163  arg23 = NULL;
19164  }
19165  }
19166  {
19167  if ( _n_dims( args(20) ) > 1 )
19168  {
19169  error( "argument must be a scalar or vector" ); SWIG_fail;
19170  }
19171  if ( !args(20).is_empty() )
19172  {
19173  if ( _dim( args(20), 0 ) != Alen )
19174  {
19175  error( "argument vectors must be same length" ); SWIG_fail;
19176  }
19177  temp24 = args(20).matrix_value();
19178  arg24 = &temp24( 0, 0 );
19179  }
19180  else
19181  {
19182  arg24 = NULL;
19183  }
19184  }
19185  {
19186  if ( _n_dims( args(21) ) > 1 )
19187  {
19188  error( "argument must be a scalar or vector" ); SWIG_fail;
19189  }
19190  if ( !args(21).is_empty() )
19191  {
19192  if ( _dim( args(21), 0 ) != Alen )
19193  {
19194  error( "argument vectors must be same length" ); SWIG_fail;
19195  }
19196  temp25 = args(21).matrix_value();
19197  arg25 = new PLINT[Alen];
19198  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
19199  }
19200  else
19201  {
19202  arg25 = NULL;
19203  }
19204  }
19205  {
19206  if ( _n_dims( args(22) ) > 1 )
19207  {
19208  error( "argument must be a scalar or vector" ); SWIG_fail;
19209  }
19210  if ( !args(22).is_empty() )
19211  {
19212  if ( _dim( args(22), 0 ) != Alen )
19213  {
19214  error( "argument vectors must be same length" ); SWIG_fail;
19215  }
19216  temp26 = args(22).matrix_value();
19217  arg26 = new PLINT[Alen];
19218  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
19219  }
19220  else
19221  {
19222  arg26 = NULL;
19223  }
19224  }
19225  {
19226  if ( _n_dims( args(23) ) > 1 )
19227  {
19228  error( "argument must be a scalar or vector" ); SWIG_fail;
19229  }
19230  if ( !args(23).is_empty() )
19231  {
19232  if ( _dim( args(23), 0 ) != Alen )
19233  {
19234  error( "argument vectors must be same length" ); SWIG_fail;
19235  }
19236  temp27 = args(23).matrix_value();
19237  arg27 = &temp27( 0, 0 );
19238  }
19239  else
19240  {
19241  arg27 = NULL;
19242  }
19243  }
19244  {
19245  if ( _n_dims( args(24) ) > 1 )
19246  {
19247  error( "argument must be a scalar or vector" ); SWIG_fail;
19248  }
19249  if ( !args(24).is_empty() )
19250  {
19251  if ( _dim( args(24), 0 ) != Alen )
19252  {
19253  error( "argument vectors must be same length" ); SWIG_fail;
19254  }
19255  temp28 = args(24).matrix_value();
19256  arg28 = new PLINT[Alen];
19257  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
19258  }
19259  else
19260  {
19261  arg28 = NULL;
19262  }
19263  }
19264  {
19265  if ( _n_dims( args(25) ) > 1 )
19266  {
19267  error( "argument must be a scalar or vector" ); SWIG_fail;
19268  }
19269  if ( !args(25).is_empty() )
19270  {
19271  if ( _dim( args(25), 0 ) != Alen )
19272  {
19273  error( "argument vectors must be same length" ); SWIG_fail;
19274  }
19275  temp29 = args(25).matrix_value();
19276  arg29 = &temp29( 0, 0 );
19277  }
19278  else
19279  {
19280  arg29 = NULL;
19281  }
19282  }
19283  {
19284  if ( _n_dims( args(26) ) > 1 )
19285  {
19286  error( "argument must be a scalar or vector" ); SWIG_fail;
19287  }
19288  if ( !args(26).is_empty() )
19289  {
19290  if ( _dim( args(26), 0 ) != Alen )
19291  {
19292  error( "argument vectors must be same length" ); SWIG_fail;
19293  }
19294  temp30 = args(26).matrix_value();
19295  arg30 = new PLINT[Alen];
19296  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
19297  }
19298  else
19299  {
19300  arg30 = NULL;
19301  }
19302  }
19303  {
19304  charMatrix temp_matrix;
19305  Cell temp_cell;
19306  char *tmp_cstring;
19307  std::string str;
19308  size_t max_length = 0, non_blank_length;
19309  int i, ifcell;
19310  if ( _n_dims( args(27) ) > 2 )
19311  {
19312  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19313  }
19314  if ( !args(27).is_empty() )
19315  {
19316  if ( _dim( args(27), 0 ) != Alen )
19317  {
19318  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19319  }
19320  arg31 = new char*[Alen];
19321  ifcell = args(27).is_cell();
19322  if ( ifcell )
19323  {
19324  temp_cell = args(27).cell_value();
19325  }
19326  else
19327  {
19328  temp_matrix = args(27).char_matrix_value();
19329  // Allow one extra space for null termination.
19330  max_length = _dim( args(27), 1 ) + 1;
19331  }
19332 
19333  for ( i = 0; i < Alen; i++ )
19334  {
19335  // Must copy string to "permanent" location because the string
19336  // location corresponding to tmp_cstring gets
19337  // overwritten for each iteration of loop.
19338  if ( ifcell )
19339  {
19340  if ( temp_cell.elem( i ).is_string() )
19341  {
19342  str = temp_cell.elem( i ).string_value();
19343  // leave room for null termination.
19344  max_length = str.size() + 1;
19345  tmp_cstring = (char *) str.c_str();
19346  }
19347  else
19348  {
19349  // Use null string if user attempts to pass a cell array
19350  // with a non-string element (likely an empty element
19351  // since that should be allowed by the PLplot interface
19352  // if that element is going to be unused).
19353  // leave room for null termination.
19354  max_length = 1;
19355  tmp_cstring = (char *) "";
19356  }
19357  }
19358  else
19359  {
19360  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
19361  }
19362  arg31[i] = new char[max_length];
19363  strncpy( arg31[i], tmp_cstring, max_length - 1 );
19364  arg31[i][max_length - 1] = '\0';
19365  // All the trailing blank crapola should not be needed for
19366  // string cell arrays.
19367  if ( !ifcell )
19368  {
19369  // remove trailing-blank padding that is used by the
19370  // charMatrix class to insure all strings in a given
19371  // charMatrix instance have the same length.
19372  // This transformation also removes legitimate trailing
19373  // blanks but there is nothing we can do about that
19374  // for the charMatrix class.
19375 
19376  // Look for trailing nulls first (just in case, although that
19377  // shouldn't happen if charMatrix implemented as documented)
19378  // before looking for trailing blanks.
19379  non_blank_length = max_length - 2;
19380  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
19381  {
19382  non_blank_length--;
19383  }
19384  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
19385  {
19386  non_blank_length--;
19387  }
19388  arg31[i][non_blank_length + 1] = '\0';
19389  }
19390  }
19391  }
19392  else
19393  {
19394  arg31 = NULL;
19395  }
19396  }
19397  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);
19398  _outv = octave_value();
19399  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19400  if (SWIG_IsTmpObj(res1)) {
19401  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19402  } else {
19403  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19404  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19405  }
19406  if (SWIG_IsTmpObj(res2)) {
19407  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19408  } else {
19409  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19410  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19411  }
19412  {
19413  delete [] arg14;
19414  }
19415  {
19416  delete [] arg19;
19417  }
19418  {
19419  int i;
19420  if ( arg20 != NULL )
19421  {
19422  for ( i = 0; i < Alen; i++ )
19423  {
19424  delete[] arg20[i];
19425  }
19426  delete[] arg20;
19427  }
19428  }
19429  {
19430  if ( arg21 != NULL )
19431  delete [] arg21;
19432  }
19433  {
19434  if ( arg22 != NULL )
19435  delete [] arg22;
19436  }
19437  {
19438 
19439  }
19440  {
19441 
19442  }
19443  {
19444  if ( arg25 != NULL )
19445  delete [] arg25;
19446  }
19447  {
19448  if ( arg26 != NULL )
19449  delete [] arg26;
19450  }
19451  {
19452 
19453  }
19454  {
19455  if ( arg28 != NULL )
19456  delete [] arg28;
19457  }
19458  {
19459 
19460  }
19461  {
19462  if ( arg30 != NULL )
19463  delete [] arg30;
19464  }
19465  {
19466  int i;
19467  if ( arg31 != NULL )
19468  {
19469  for ( i = 0; i < Alen; i++ )
19470  {
19471  delete[] arg31[i];
19472  }
19473  delete[] arg31;
19474  }
19475  }
19476  return _out;
19477 fail:
19478  {
19479  delete [] arg14;
19480  }
19481  {
19482  delete [] arg19;
19483  }
19484  {
19485  int i;
19486  if ( arg20 != NULL )
19487  {
19488  for ( i = 0; i < Alen; i++ )
19489  {
19490  delete[] arg20[i];
19491  }
19492  delete[] arg20;
19493  }
19494  }
19495  {
19496  if ( arg21 != NULL )
19497  delete [] arg21;
19498  }
19499  {
19500  if ( arg22 != NULL )
19501  delete [] arg22;
19502  }
19503  {
19504 
19505  }
19506  {
19507 
19508  }
19509  {
19510  if ( arg25 != NULL )
19511  delete [] arg25;
19512  }
19513  {
19514  if ( arg26 != NULL )
19515  delete [] arg26;
19516  }
19517  {
19518 
19519  }
19520  {
19521  if ( arg28 != NULL )
19522  delete [] arg28;
19523  }
19524  {
19525 
19526  }
19527  {
19528  if ( arg30 != NULL )
19529  delete [] arg30;
19530  }
19531  {
19532  int i;
19533  if ( arg31 != NULL )
19534  {
19535  for ( i = 0; i < Alen; i++ )
19536  {
19537  delete[] arg31[i];
19538  }
19539  delete[] arg31;
19540  }
19541  }
19542  return octave_value_list();
19543 }
19544 
19545 
19546 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
19547  PLFLT arg1 ;
19548  PLFLT arg2 ;
19549  PLFLT arg3 ;
19550  double val1 ;
19551  int ecode1 = 0 ;
19552  double val2 ;
19553  int ecode2 = 0 ;
19554  double val3 ;
19555  int ecode3 = 0 ;
19556  octave_value_list _out;
19557  octave_value_list *_outp=&_out;
19558  octave_value _outv;
19559 
19560  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
19561  SWIG_fail;
19562  }
19563  ecode1 = SWIG_AsVal_double(args(0), &val1);
19564  if (!SWIG_IsOK(ecode1)) {
19565  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
19566  }
19567  arg1 = (PLFLT)(val1);
19568  ecode2 = SWIG_AsVal_double(args(1), &val2);
19569  if (!SWIG_IsOK(ecode2)) {
19570  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
19571  }
19572  arg2 = (PLFLT)(val2);
19573  ecode3 = SWIG_AsVal_double(args(2), &val3);
19574  if (!SWIG_IsOK(ecode3)) {
19575  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
19576  }
19577  arg3 = (PLFLT)(val3);
19578  pllightsource(arg1,arg2,arg3);
19579  _outv = octave_value();
19580  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19581  return _out;
19582 fail:
19583  return octave_value_list();
19584 }
19585 
19586 
19587 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
19588  PLINT arg1 ;
19589  PLFLT *arg2 = (PLFLT *) 0 ;
19590  PLFLT *arg3 = (PLFLT *) 0 ;
19591  Matrix temp1 ;
19592  Matrix temp3 ;
19593  octave_value_list _out;
19594  octave_value_list *_outp=&_out;
19595  octave_value _outv;
19596 
19597  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
19598  SWIG_fail;
19599  }
19600  {
19601  if ( _n_dims( args(0) ) > 1 )
19602  {
19603  error( "argument must be a scalar or vector" ); SWIG_fail;
19604  }
19605  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19606  temp1 = args(0).matrix_value();
19607  arg2 = &temp1( 0, 0 );
19608  }
19609  {
19610  if ( _n_dims( args(1) ) > 1 )
19611  {
19612  error( "argument must be a scalar or vector" ); SWIG_fail;
19613  }
19614  if ( _dim( args(1), 0 ) != Alen )
19615  {
19616  error( "argument vectors must be same length" ); SWIG_fail;
19617  }
19618  temp3 = args(1).matrix_value();
19619  arg3 = &temp3( 0, 0 );
19620  }
19621  plline(arg1,(double const *)arg2,(double const *)arg3);
19622  _outv = octave_value();
19623  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19624  {
19625 
19626  }
19627  {
19628 
19629  }
19630  return _out;
19631 fail:
19632  {
19633 
19634  }
19635  {
19636 
19637  }
19638  return octave_value_list();
19639 }
19640 
19641 
19642 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
19643  PLINT arg1 ;
19644  PLFLT *arg2 = (PLFLT *) 0 ;
19645  PLFLT *arg3 = (PLFLT *) 0 ;
19646  PLFLT *arg4 = (PLFLT *) 0 ;
19647  Matrix temp1 ;
19648  Matrix temp3 ;
19649  Matrix temp4 ;
19650  octave_value_list _out;
19651  octave_value_list *_outp=&_out;
19652  octave_value _outv;
19653 
19654  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
19655  SWIG_fail;
19656  }
19657  {
19658  if ( _n_dims( args(0) ) > 1 )
19659  {
19660  error( "argument must be a scalar or vector" ); SWIG_fail;
19661  }
19662  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19663  temp1 = args(0).matrix_value();
19664  arg2 = &temp1( 0, 0 );
19665  }
19666  {
19667  if ( _n_dims( args(1) ) > 1 )
19668  {
19669  error( "argument must be a scalar or vector" ); SWIG_fail;
19670  }
19671  if ( _dim( args(1), 0 ) != Alen )
19672  {
19673  error( "argument vectors must be same length" ); SWIG_fail;
19674  }
19675  temp3 = args(1).matrix_value();
19676  arg3 = &temp3( 0, 0 );
19677  }
19678  {
19679  if ( _n_dims( args(2) ) > 1 )
19680  {
19681  error( "argument must be a scalar or vector" ); SWIG_fail;
19682  }
19683  if ( _dim( args(2), 0 ) != Alen )
19684  {
19685  error( "argument vectors must be same length" ); SWIG_fail;
19686  }
19687  temp4 = args(2).matrix_value();
19688  arg4 = &temp4( 0, 0 );
19689  }
19690  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
19691  _outv = octave_value();
19692  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19693  {
19694 
19695  }
19696  {
19697 
19698  }
19699  {
19700 
19701  }
19702  return _out;
19703 fail:
19704  {
19705 
19706  }
19707  {
19708 
19709  }
19710  {
19711 
19712  }
19713  return octave_value_list();
19714 }
19715 
19716 
19717 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
19718  PLINT arg1 ;
19719  int val1 ;
19720  int ecode1 = 0 ;
19721  octave_value_list _out;
19722  octave_value_list *_outp=&_out;
19723  octave_value _outv;
19724 
19725  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
19726  SWIG_fail;
19727  }
19728  ecode1 = SWIG_AsVal_int(args(0), &val1);
19729  if (!SWIG_IsOK(ecode1)) {
19730  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
19731  }
19732  arg1 = (PLINT)(val1);
19733  pllsty(arg1);
19734  _outv = octave_value();
19735  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19736  return _out;
19737 fail:
19738  return octave_value_list();
19739 }
19740 
19741 
19742 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
19743  PLINT *arg1 = (PLINT *) 0 ;
19744  PLINT temp1 ;
19745  int res1 = SWIG_TMPOBJ ;
19746  octave_value_list _out;
19747  octave_value_list *_outp=&_out;
19748  octave_value _outv;
19749 
19750  arg1 = &temp1;
19751  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
19752  SWIG_fail;
19753  }
19754  plmkstrm(arg1);
19755  _outv = octave_value();
19756  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19757  if (SWIG_IsTmpObj(res1)) {
19758  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19759  } else {
19760  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19761  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19762  }
19763  return _out;
19764 fail:
19765  return octave_value_list();
19766 }
19767 
19768 
19769 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
19770  char *arg1 = (char *) 0 ;
19771  PLFLT arg2 ;
19772  PLFLT arg3 ;
19773  PLFLT arg4 ;
19774  char *arg5 = (char *) 0 ;
19775  int res1 ;
19776  char *buf1 = 0 ;
19777  int alloc1 = 0 ;
19778  double val2 ;
19779  int ecode2 = 0 ;
19780  double val3 ;
19781  int ecode3 = 0 ;
19782  double val4 ;
19783  int ecode4 = 0 ;
19784  int res5 ;
19785  char *buf5 = 0 ;
19786  int alloc5 = 0 ;
19787  octave_value_list _out;
19788  octave_value_list *_outp=&_out;
19789  octave_value _outv;
19790 
19791  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
19792  SWIG_fail;
19793  }
19794  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19795  if (!SWIG_IsOK(res1)) {
19796  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
19797  }
19798  arg1 = (char *)(buf1);
19799  ecode2 = SWIG_AsVal_double(args(1), &val2);
19800  if (!SWIG_IsOK(ecode2)) {
19801  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
19802  }
19803  arg2 = (PLFLT)(val2);
19804  ecode3 = SWIG_AsVal_double(args(2), &val3);
19805  if (!SWIG_IsOK(ecode3)) {
19806  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
19807  }
19808  arg3 = (PLFLT)(val3);
19809  ecode4 = SWIG_AsVal_double(args(3), &val4);
19810  if (!SWIG_IsOK(ecode4)) {
19811  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
19812  }
19813  arg4 = (PLFLT)(val4);
19814  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
19815  if (!SWIG_IsOK(res5)) {
19816  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
19817  }
19818  arg5 = (char *)(buf5);
19819  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
19820  _outv = octave_value();
19821  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19822  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19823  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19824  return _out;
19825 fail:
19826  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19827  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19828  return octave_value_list();
19829 }
19830 
19831 
19832 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
19833  char *arg1 = (char *) 0 ;
19834  PLFLT arg2 ;
19835  PLFLT arg3 ;
19836  PLFLT arg4 ;
19837  char *arg5 = (char *) 0 ;
19838  int res1 ;
19839  char *buf1 = 0 ;
19840  int alloc1 = 0 ;
19841  double val2 ;
19842  int ecode2 = 0 ;
19843  double val3 ;
19844  int ecode3 = 0 ;
19845  double val4 ;
19846  int ecode4 = 0 ;
19847  int res5 ;
19848  char *buf5 = 0 ;
19849  int alloc5 = 0 ;
19850  octave_value_list _out;
19851  octave_value_list *_outp=&_out;
19852  octave_value _outv;
19853 
19854  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
19855  SWIG_fail;
19856  }
19857  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19858  if (!SWIG_IsOK(res1)) {
19859  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
19860  }
19861  arg1 = (char *)(buf1);
19862  ecode2 = SWIG_AsVal_double(args(1), &val2);
19863  if (!SWIG_IsOK(ecode2)) {
19864  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
19865  }
19866  arg2 = (PLFLT)(val2);
19867  ecode3 = SWIG_AsVal_double(args(2), &val3);
19868  if (!SWIG_IsOK(ecode3)) {
19869  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
19870  }
19871  arg3 = (PLFLT)(val3);
19872  ecode4 = SWIG_AsVal_double(args(3), &val4);
19873  if (!SWIG_IsOK(ecode4)) {
19874  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
19875  }
19876  arg4 = (PLFLT)(val4);
19877  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
19878  if (!SWIG_IsOK(res5)) {
19879  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
19880  }
19881  arg5 = (char *)(buf5);
19882  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
19883  _outv = octave_value();
19884  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19885  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19886  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19887  return _out;
19888 fail:
19889  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19890  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19891  return octave_value_list();
19892 }
19893 
19894 
19895 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
19896  int *arg1 = (int *) 0 ;
19897  char **arg2 = (char **) 0 ;
19898  PLINT arg3 ;
19899  void *argp1 = 0 ;
19900  int res1 = 0 ;
19901  void *argp2 = 0 ;
19902  int res2 = 0 ;
19903  int val3 ;
19904  int ecode3 = 0 ;
19905  octave_value_list _out;
19906  octave_value_list *_outp=&_out;
19907  octave_value _outv;
19908  PLINT result;
19909 
19910  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
19911  SWIG_fail;
19912  }
19913  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
19914  if (!SWIG_IsOK(res1)) {
19915  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
19916  }
19917  arg1 = (int *)(argp1);
19918  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
19919  if (!SWIG_IsOK(res2)) {
19920  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
19921  }
19922  arg2 = (char **)(argp2);
19923  ecode3 = SWIG_AsVal_int(args(2), &val3);
19924  if (!SWIG_IsOK(ecode3)) {
19925  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
19926  }
19927  arg3 = (PLINT)(val3);
19928  result = (PLINT)plparseopts(arg1,arg2,arg3);
19929  _outv = SWIG_From_int((int)(result));
19930  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19931  return _out;
19932 fail:
19933  return octave_value_list();
19934 }
19935 
19936 
19937 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
19938  PLINT arg1 ;
19939  PLINT *arg2 = (PLINT *) 0 ;
19940  PLINT *arg3 = (PLINT *) 0 ;
19941  Matrix temp1 ;
19942  Matrix temp3 ;
19943  octave_value_list _out;
19944  octave_value_list *_outp=&_out;
19945  octave_value _outv;
19946 
19947  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
19948  SWIG_fail;
19949  }
19950  {
19951  if ( _n_dims( args(0) ) > 1 )
19952  {
19953  error( "argument must be a scalar or vector" ); SWIG_fail;
19954  }
19955  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19956  arg2 = new PLINT[Alen];
19957  temp1 = args(0).matrix_value();
19958  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
19959  }
19960  {
19961  if ( _n_dims( args(1) ) > 1 )
19962  {
19963  error( "argument must be a scalar or vector" ); SWIG_fail;
19964  }
19965  if ( _dim( args(1), 0 ) != Alen )
19966  {
19967  error( "argument vectors must be same length" ); SWIG_fail;
19968  }
19969  temp3 = args(1).matrix_value();
19970  arg3 = new PLINT[Alen];
19971  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19972  }
19973  plpat(arg1,(int const *)arg2,(int const *)arg3);
19974  _outv = octave_value();
19975  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19976  {
19977  delete [] arg2;
19978  }
19979  {
19980  delete [] arg3;
19981  }
19982  return _out;
19983 fail:
19984  {
19985  delete [] arg2;
19986  }
19987  {
19988  delete [] arg3;
19989  }
19990  return octave_value_list();
19991 }
19992 
19993 
19994 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
19995  PLINT arg1 ;
19996  PLFLT arg2 ;
19997  PLFLT arg3 ;
19998  PLFLT arg4 ;
19999  PLFLT arg5 ;
20000  int val1 ;
20001  int ecode1 = 0 ;
20002  double val2 ;
20003  int ecode2 = 0 ;
20004  double val3 ;
20005  int ecode3 = 0 ;
20006  double val4 ;
20007  int ecode4 = 0 ;
20008  double val5 ;
20009  int ecode5 = 0 ;
20010  octave_value_list _out;
20011  octave_value_list *_outp=&_out;
20012  octave_value _outv;
20013 
20014  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
20015  SWIG_fail;
20016  }
20017  ecode1 = SWIG_AsVal_int(args(0), &val1);
20018  if (!SWIG_IsOK(ecode1)) {
20019  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
20020  }
20021  arg1 = (PLINT)(val1);
20022  ecode2 = SWIG_AsVal_double(args(1), &val2);
20023  if (!SWIG_IsOK(ecode2)) {
20024  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
20025  }
20026  arg2 = (PLFLT)(val2);
20027  ecode3 = SWIG_AsVal_double(args(2), &val3);
20028  if (!SWIG_IsOK(ecode3)) {
20029  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
20030  }
20031  arg3 = (PLFLT)(val3);
20032  ecode4 = SWIG_AsVal_double(args(3), &val4);
20033  if (!SWIG_IsOK(ecode4)) {
20034  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
20035  }
20036  arg4 = (PLFLT)(val4);
20037  ecode5 = SWIG_AsVal_double(args(4), &val5);
20038  if (!SWIG_IsOK(ecode5)) {
20039  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
20040  }
20041  arg5 = (PLFLT)(val5);
20042  plpath(arg1,arg2,arg3,arg4,arg5);
20043  _outv = octave_value();
20044  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20045  return _out;
20046 fail:
20047  return octave_value_list();
20048 }
20049 
20050 
20051 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
20052  PLINT arg1 ;
20053  PLFLT *arg2 = (PLFLT *) 0 ;
20054  PLFLT *arg3 = (PLFLT *) 0 ;
20055  PLINT arg4 ;
20056  Matrix temp1 ;
20057  Matrix temp3 ;
20058  int val4 ;
20059  int ecode4 = 0 ;
20060  octave_value_list _out;
20061  octave_value_list *_outp=&_out;
20062  octave_value _outv;
20063 
20064  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
20065  SWIG_fail;
20066  }
20067  {
20068  if ( _n_dims( args(0) ) > 1 )
20069  {
20070  error( "argument must be a scalar or vector" ); SWIG_fail;
20071  }
20072  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20073  temp1 = args(0).matrix_value();
20074  arg2 = &temp1( 0, 0 );
20075  }
20076  {
20077  if ( _n_dims( args(1) ) > 1 )
20078  {
20079  error( "argument must be a scalar or vector" ); SWIG_fail;
20080  }
20081  if ( _dim( args(1), 0 ) != Alen )
20082  {
20083  error( "argument vectors must be same length" ); SWIG_fail;
20084  }
20085  temp3 = args(1).matrix_value();
20086  arg3 = &temp3( 0, 0 );
20087  }
20088  ecode4 = SWIG_AsVal_int(args(2), &val4);
20089  if (!SWIG_IsOK(ecode4)) {
20090  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
20091  }
20092  arg4 = (PLINT)(val4);
20093  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
20094  _outv = octave_value();
20095  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20096  {
20097 
20098  }
20099  {
20100 
20101  }
20102  return _out;
20103 fail:
20104  {
20105 
20106  }
20107  {
20108 
20109  }
20110  return octave_value_list();
20111 }
20112 
20113 
20114 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
20115  PLINT arg1 ;
20116  PLFLT *arg2 = (PLFLT *) 0 ;
20117  PLFLT *arg3 = (PLFLT *) 0 ;
20118  PLFLT *arg4 = (PLFLT *) 0 ;
20119  PLINT arg5 ;
20120  Matrix temp1 ;
20121  Matrix temp3 ;
20122  Matrix temp4 ;
20123  int val5 ;
20124  int ecode5 = 0 ;
20125  octave_value_list _out;
20126  octave_value_list *_outp=&_out;
20127  octave_value _outv;
20128 
20129  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
20130  SWIG_fail;
20131  }
20132  {
20133  if ( _n_dims( args(0) ) > 1 )
20134  {
20135  error( "argument must be a scalar or vector" ); SWIG_fail;
20136  }
20137  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20138  temp1 = args(0).matrix_value();
20139  arg2 = &temp1( 0, 0 );
20140  }
20141  {
20142  if ( _n_dims( args(1) ) > 1 )
20143  {
20144  error( "argument must be a scalar or vector" ); SWIG_fail;
20145  }
20146  if ( _dim( args(1), 0 ) != Alen )
20147  {
20148  error( "argument vectors must be same length" ); SWIG_fail;
20149  }
20150  temp3 = args(1).matrix_value();
20151  arg3 = &temp3( 0, 0 );
20152  }
20153  {
20154  if ( _n_dims( args(2) ) > 1 )
20155  {
20156  error( "argument must be a scalar or vector" ); SWIG_fail;
20157  }
20158  if ( _dim( args(2), 0 ) != Alen )
20159  {
20160  error( "argument vectors must be same length" ); SWIG_fail;
20161  }
20162  temp4 = args(2).matrix_value();
20163  arg4 = &temp4( 0, 0 );
20164  }
20165  ecode5 = SWIG_AsVal_int(args(3), &val5);
20166  if (!SWIG_IsOK(ecode5)) {
20167  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
20168  }
20169  arg5 = (PLINT)(val5);
20170  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
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  return _out;
20183 fail:
20184  {
20185 
20186  }
20187  {
20188 
20189  }
20190  {
20191 
20192  }
20193  return octave_value_list();
20194 }
20195 
20196 
20197 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
20198  PLINT arg1 ;
20199  PLFLT *arg2 = (PLFLT *) 0 ;
20200  PLFLT *arg3 = (PLFLT *) 0 ;
20201  PLFLT *arg4 = (PLFLT *) 0 ;
20202  PLBOOL *arg5 = (PLBOOL *) 0 ;
20203  PLBOOL arg6 ;
20204  Matrix temp1 ;
20205  Matrix temp3 ;
20206  Matrix temp4 ;
20207  Matrix temp5 ;
20208  int val6 ;
20209  int ecode6 = 0 ;
20210  octave_value_list _out;
20211  octave_value_list *_outp=&_out;
20212  octave_value _outv;
20213 
20214  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
20215  SWIG_fail;
20216  }
20217  {
20218  if ( _n_dims( args(0) ) > 1 )
20219  {
20220  error( "argument must be a scalar or vector" ); SWIG_fail;
20221  }
20222  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20223  temp1 = args(0).matrix_value();
20224  arg2 = &temp1( 0, 0 );
20225  }
20226  {
20227  if ( _n_dims( args(1) ) > 1 )
20228  {
20229  error( "argument must be a scalar or vector" ); SWIG_fail;
20230  }
20231  if ( _dim( args(1), 0 ) != Alen )
20232  {
20233  error( "argument vectors must be same length" ); SWIG_fail;
20234  }
20235  temp3 = args(1).matrix_value();
20236  arg3 = &temp3( 0, 0 );
20237  }
20238  {
20239  if ( _n_dims( args(2) ) > 1 )
20240  {
20241  error( "argument must be a scalar or vector" ); SWIG_fail;
20242  }
20243  if ( _dim( args(2), 0 ) != Alen )
20244  {
20245  error( "argument vectors must be same length" ); SWIG_fail;
20246  }
20247  temp4 = args(2).matrix_value();
20248  arg4 = &temp4( 0, 0 );
20249  }
20250  {
20251  if ( _n_dims( args(3) ) > 1 )
20252  {
20253  error( "argument must be a scalar or vector" ); SWIG_fail;
20254  }
20255  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
20256  {
20257  error( "argument vector must be same length or one less" ); SWIG_fail;
20258  }
20259  temp5 = args(3).matrix_value();
20260  arg5 = new PLINT[Alen];
20261  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
20262  }
20263  ecode6 = SWIG_AsVal_int(args(4), &val6);
20264  if (!SWIG_IsOK(ecode6)) {
20265  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
20266  }
20267  arg6 = (PLBOOL)(val6);
20268  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
20269  _outv = octave_value();
20270  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20271  {
20272 
20273  }
20274  {
20275 
20276  }
20277  {
20278 
20279  }
20280  {
20281  delete [] arg5;
20282  }
20283  return _out;
20284 fail:
20285  {
20286 
20287  }
20288  {
20289 
20290  }
20291  {
20292 
20293  }
20294  {
20295  delete [] arg5;
20296  }
20297  return octave_value_list();
20298 }
20299 
20300 
20301 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
20302  PLINT arg1 ;
20303  PLINT arg2 ;
20304  int val1 ;
20305  int ecode1 = 0 ;
20306  int val2 ;
20307  int ecode2 = 0 ;
20308  octave_value_list _out;
20309  octave_value_list *_outp=&_out;
20310  octave_value _outv;
20311 
20312  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
20313  SWIG_fail;
20314  }
20315  ecode1 = SWIG_AsVal_int(args(0), &val1);
20316  if (!SWIG_IsOK(ecode1)) {
20317  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
20318  }
20319  arg1 = (PLINT)(val1);
20320  ecode2 = SWIG_AsVal_int(args(1), &val2);
20321  if (!SWIG_IsOK(ecode2)) {
20322  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
20323  }
20324  arg2 = (PLINT)(val2);
20325  plprec(arg1,arg2);
20326  _outv = octave_value();
20327  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20328  return _out;
20329 fail:
20330  return octave_value_list();
20331 }
20332 
20333 
20334 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
20335  PLINT arg1 ;
20336  int val1 ;
20337  int ecode1 = 0 ;
20338  octave_value_list _out;
20339  octave_value_list *_outp=&_out;
20340  octave_value _outv;
20341 
20342  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
20343  SWIG_fail;
20344  }
20345  ecode1 = SWIG_AsVal_int(args(0), &val1);
20346  if (!SWIG_IsOK(ecode1)) {
20347  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
20348  }
20349  arg1 = (PLINT)(val1);
20350  plpsty(arg1);
20351  _outv = octave_value();
20352  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20353  return _out;
20354 fail:
20355  return octave_value_list();
20356 }
20357 
20358 
20359 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
20360  PLFLT arg1 ;
20361  PLFLT arg2 ;
20362  PLFLT arg3 ;
20363  PLFLT arg4 ;
20364  PLFLT arg5 ;
20365  char *arg6 = (char *) 0 ;
20366  double val1 ;
20367  int ecode1 = 0 ;
20368  double val2 ;
20369  int ecode2 = 0 ;
20370  double val3 ;
20371  int ecode3 = 0 ;
20372  double val4 ;
20373  int ecode4 = 0 ;
20374  double val5 ;
20375  int ecode5 = 0 ;
20376  int res6 ;
20377  char *buf6 = 0 ;
20378  int alloc6 = 0 ;
20379  octave_value_list _out;
20380  octave_value_list *_outp=&_out;
20381  octave_value _outv;
20382 
20383  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
20384  SWIG_fail;
20385  }
20386  ecode1 = SWIG_AsVal_double(args(0), &val1);
20387  if (!SWIG_IsOK(ecode1)) {
20388  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
20389  }
20390  arg1 = (PLFLT)(val1);
20391  ecode2 = SWIG_AsVal_double(args(1), &val2);
20392  if (!SWIG_IsOK(ecode2)) {
20393  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
20394  }
20395  arg2 = (PLFLT)(val2);
20396  ecode3 = SWIG_AsVal_double(args(2), &val3);
20397  if (!SWIG_IsOK(ecode3)) {
20398  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
20399  }
20400  arg3 = (PLFLT)(val3);
20401  ecode4 = SWIG_AsVal_double(args(3), &val4);
20402  if (!SWIG_IsOK(ecode4)) {
20403  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
20404  }
20405  arg4 = (PLFLT)(val4);
20406  ecode5 = SWIG_AsVal_double(args(4), &val5);
20407  if (!SWIG_IsOK(ecode5)) {
20408  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
20409  }
20410  arg5 = (PLFLT)(val5);
20411  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
20412  if (!SWIG_IsOK(res6)) {
20413  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
20414  }
20415  arg6 = (char *)(buf6);
20416  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
20417  _outv = octave_value();
20418  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20419  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20420  return _out;
20421 fail:
20422  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20423  return octave_value_list();
20424 }
20425 
20426 
20427 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
20428  PLFLT arg1 ;
20429  PLFLT arg2 ;
20430  PLFLT arg3 ;
20431  PLFLT arg4 ;
20432  PLFLT arg5 ;
20433  PLFLT arg6 ;
20434  PLFLT arg7 ;
20435  PLFLT arg8 ;
20436  PLFLT arg9 ;
20437  PLFLT arg10 ;
20438  char *arg11 = (char *) 0 ;
20439  double val1 ;
20440  int ecode1 = 0 ;
20441  double val2 ;
20442  int ecode2 = 0 ;
20443  double val3 ;
20444  int ecode3 = 0 ;
20445  double val4 ;
20446  int ecode4 = 0 ;
20447  double val5 ;
20448  int ecode5 = 0 ;
20449  double val6 ;
20450  int ecode6 = 0 ;
20451  double val7 ;
20452  int ecode7 = 0 ;
20453  double val8 ;
20454  int ecode8 = 0 ;
20455  double val9 ;
20456  int ecode9 = 0 ;
20457  double val10 ;
20458  int ecode10 = 0 ;
20459  int res11 ;
20460  char *buf11 = 0 ;
20461  int alloc11 = 0 ;
20462  octave_value_list _out;
20463  octave_value_list *_outp=&_out;
20464  octave_value _outv;
20465 
20466  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
20467  SWIG_fail;
20468  }
20469  ecode1 = SWIG_AsVal_double(args(0), &val1);
20470  if (!SWIG_IsOK(ecode1)) {
20471  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
20472  }
20473  arg1 = (PLFLT)(val1);
20474  ecode2 = SWIG_AsVal_double(args(1), &val2);
20475  if (!SWIG_IsOK(ecode2)) {
20476  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
20477  }
20478  arg2 = (PLFLT)(val2);
20479  ecode3 = SWIG_AsVal_double(args(2), &val3);
20480  if (!SWIG_IsOK(ecode3)) {
20481  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
20482  }
20483  arg3 = (PLFLT)(val3);
20484  ecode4 = SWIG_AsVal_double(args(3), &val4);
20485  if (!SWIG_IsOK(ecode4)) {
20486  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
20487  }
20488  arg4 = (PLFLT)(val4);
20489  ecode5 = SWIG_AsVal_double(args(4), &val5);
20490  if (!SWIG_IsOK(ecode5)) {
20491  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
20492  }
20493  arg5 = (PLFLT)(val5);
20494  ecode6 = SWIG_AsVal_double(args(5), &val6);
20495  if (!SWIG_IsOK(ecode6)) {
20496  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
20497  }
20498  arg6 = (PLFLT)(val6);
20499  ecode7 = SWIG_AsVal_double(args(6), &val7);
20500  if (!SWIG_IsOK(ecode7)) {
20501  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
20502  }
20503  arg7 = (PLFLT)(val7);
20504  ecode8 = SWIG_AsVal_double(args(7), &val8);
20505  if (!SWIG_IsOK(ecode8)) {
20506  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
20507  }
20508  arg8 = (PLFLT)(val8);
20509  ecode9 = SWIG_AsVal_double(args(8), &val9);
20510  if (!SWIG_IsOK(ecode9)) {
20511  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
20512  }
20513  arg9 = (PLFLT)(val9);
20514  ecode10 = SWIG_AsVal_double(args(9), &val10);
20515  if (!SWIG_IsOK(ecode10)) {
20516  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
20517  }
20518  arg10 = (PLFLT)(val10);
20519  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
20520  if (!SWIG_IsOK(res11)) {
20521  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
20522  }
20523  arg11 = (char *)(buf11);
20524  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
20525  _outv = octave_value();
20526  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20527  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20528  return _out;
20529 fail:
20530  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20531  return octave_value_list();
20532 }
20533 
20534 
20535 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
20536  octave_value_list _out;
20537  octave_value_list *_outp=&_out;
20538  octave_value _outv;
20539  PLFLT result;
20540 
20541  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
20542  SWIG_fail;
20543  }
20544  result = (PLFLT)plrandd();
20545  _outv = SWIG_From_double((double)(result));
20546  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20547  return _out;
20548 fail:
20549  return octave_value_list();
20550 }
20551 
20552 
20553 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
20554  octave_value_list _out;
20555  octave_value_list *_outp=&_out;
20556  octave_value _outv;
20557 
20558  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
20559  SWIG_fail;
20560  }
20561  plreplot();
20562  _outv = octave_value();
20563  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20564  return _out;
20565 fail:
20566  return octave_value_list();
20567 }
20568 
20569 
20570 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
20571  PLFLT arg1 ;
20572  PLFLT arg2 ;
20573  PLFLT arg3 ;
20574  PLFLT *arg4 = (PLFLT *) 0 ;
20575  PLFLT *arg5 = (PLFLT *) 0 ;
20576  PLFLT *arg6 = (PLFLT *) 0 ;
20577  double val1 ;
20578  int ecode1 = 0 ;
20579  double val2 ;
20580  int ecode2 = 0 ;
20581  double val3 ;
20582  int ecode3 = 0 ;
20583  PLFLT temp4 ;
20584  int res4 = SWIG_TMPOBJ ;
20585  PLFLT temp5 ;
20586  int res5 = SWIG_TMPOBJ ;
20587  PLFLT temp6 ;
20588  int res6 = SWIG_TMPOBJ ;
20589  octave_value_list _out;
20590  octave_value_list *_outp=&_out;
20591  octave_value _outv;
20592 
20593  arg4 = &temp4;
20594  arg5 = &temp5;
20595  arg6 = &temp6;
20596  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
20597  SWIG_fail;
20598  }
20599  ecode1 = SWIG_AsVal_double(args(0), &val1);
20600  if (!SWIG_IsOK(ecode1)) {
20601  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
20602  }
20603  arg1 = (PLFLT)(val1);
20604  ecode2 = SWIG_AsVal_double(args(1), &val2);
20605  if (!SWIG_IsOK(ecode2)) {
20606  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
20607  }
20608  arg2 = (PLFLT)(val2);
20609  ecode3 = SWIG_AsVal_double(args(2), &val3);
20610  if (!SWIG_IsOK(ecode3)) {
20611  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
20612  }
20613  arg3 = (PLFLT)(val3);
20614  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
20615  _outv = octave_value();
20616  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20617  if (SWIG_IsTmpObj(res4)) {
20618  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20619  } else {
20620  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20621  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20622  }
20623  if (SWIG_IsTmpObj(res5)) {
20624  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20625  } else {
20626  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20627  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20628  }
20629  if (SWIG_IsTmpObj(res6)) {
20630  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20631  } else {
20632  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20633  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20634  }
20635  return _out;
20636 fail:
20637  return octave_value_list();
20638 }
20639 
20640 
20641 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
20642  PLFLT arg1 ;
20643  PLFLT arg2 ;
20644  double val1 ;
20645  int ecode1 = 0 ;
20646  double val2 ;
20647  int ecode2 = 0 ;
20648  octave_value_list _out;
20649  octave_value_list *_outp=&_out;
20650  octave_value _outv;
20651 
20652  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
20653  SWIG_fail;
20654  }
20655  ecode1 = SWIG_AsVal_double(args(0), &val1);
20656  if (!SWIG_IsOK(ecode1)) {
20657  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
20658  }
20659  arg1 = (PLFLT)(val1);
20660  ecode2 = SWIG_AsVal_double(args(1), &val2);
20661  if (!SWIG_IsOK(ecode2)) {
20662  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
20663  }
20664  arg2 = (PLFLT)(val2);
20665  plschr(arg1,arg2);
20666  _outv = octave_value();
20667  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20668  return _out;
20669 fail:
20670  return octave_value_list();
20671 }
20672 
20673 
20674 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
20675  PLINT *arg1 = (PLINT *) 0 ;
20676  PLINT *arg2 = (PLINT *) 0 ;
20677  PLINT *arg3 = (PLINT *) 0 ;
20678  PLINT arg4 ;
20679  Matrix temp1 ;
20680  Matrix temp2 ;
20681  Matrix temp3 ;
20682  octave_value_list _out;
20683  octave_value_list *_outp=&_out;
20684  octave_value _outv;
20685 
20686  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
20687  SWIG_fail;
20688  }
20689  {
20690  if ( _n_dims( args(0) ) > 1 )
20691  {
20692  error( "argument must be a scalar or vector" ); SWIG_fail;
20693  }
20694  Alen = (PLINT) ( _dim( args(0), 0 ) );
20695  temp1 = args(0).matrix_value();
20696  arg1 = new PLINT[Alen];
20697  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
20698  }
20699  {
20700  if ( _n_dims( args(1) ) > 1 )
20701  {
20702  error( "argument must be a scalar or vector" ); SWIG_fail;
20703  }
20704  if ( _dim( args(1), 0 ) != Alen )
20705  {
20706  error( "argument vectors must be same length" ); SWIG_fail;
20707  }
20708  temp2 = args(1).matrix_value();
20709  arg2 = new PLINT[Alen];
20710  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
20711  }
20712  {
20713  if ( _n_dims( args(2) ) > 1 )
20714  {
20715  error( "argument must be a scalar or vector" ); SWIG_fail;
20716  }
20717  if ( _dim( args(2), 0 ) != Alen )
20718  {
20719  error( "argument vectors must be same length" ); SWIG_fail;
20720  }
20721  temp3 = args(2).matrix_value();
20722  arg3 = new PLINT[Alen];
20723  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20724  arg4 = Alen;
20725  }
20726  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
20727  _outv = octave_value();
20728  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20729  {
20730  delete [] arg1;
20731  }
20732  {
20733  delete [] arg2;
20734  }
20735  {
20736  delete [] arg3;
20737  }
20738  return _out;
20739 fail:
20740  {
20741  delete [] arg1;
20742  }
20743  {
20744  delete [] arg2;
20745  }
20746  {
20747  delete [] arg3;
20748  }
20749  return octave_value_list();
20750 }
20751 
20752 
20753 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
20754  PLINT *arg1 = (PLINT *) 0 ;
20755  PLINT *arg2 = (PLINT *) 0 ;
20756  PLINT *arg3 = (PLINT *) 0 ;
20757  PLFLT *arg4 = (PLFLT *) 0 ;
20758  PLINT arg5 ;
20759  Matrix temp1 ;
20760  Matrix temp2 ;
20761  Matrix temp3 ;
20762  Matrix temp4 ;
20763  octave_value_list _out;
20764  octave_value_list *_outp=&_out;
20765  octave_value _outv;
20766 
20767  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
20768  SWIG_fail;
20769  }
20770  {
20771  if ( _n_dims( args(0) ) > 1 )
20772  {
20773  error( "argument must be a scalar or vector" ); SWIG_fail;
20774  }
20775  Alen = (PLINT) ( _dim( args(0), 0 ) );
20776  temp1 = args(0).matrix_value();
20777  arg1 = new PLINT[Alen];
20778  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
20779  }
20780  {
20781  if ( _n_dims( args(1) ) > 1 )
20782  {
20783  error( "argument must be a scalar or vector" ); SWIG_fail;
20784  }
20785  if ( _dim( args(1), 0 ) != Alen )
20786  {
20787  error( "argument vectors must be same length" ); SWIG_fail;
20788  }
20789  temp2 = args(1).matrix_value();
20790  arg2 = new PLINT[Alen];
20791  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
20792  }
20793  {
20794  if ( _n_dims( args(2) ) > 1 )
20795  {
20796  error( "argument must be a scalar or vector" ); SWIG_fail;
20797  }
20798  if ( _dim( args(2), 0 ) != Alen )
20799  {
20800  error( "argument vectors must be same length" ); SWIG_fail;
20801  }
20802  temp3 = args(2).matrix_value();
20803  arg3 = new PLINT[Alen];
20804  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20805  }
20806  {
20807  if ( _n_dims( args(3) ) > 1 )
20808  {
20809  error( "argument must be a scalar or vector" ); SWIG_fail;
20810  }
20811  if ( _dim( args(3), 0 ) != Alen )
20812  {
20813  error( "argument vectors must be same length" ); SWIG_fail;
20814  }
20815  temp4 = args(3).matrix_value();
20816  arg4 = &temp4( 0, 0 );
20817  arg5 = (PLINT) ( _dim( args(3), 0 ) );
20818  }
20819  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
20820  _outv = octave_value();
20821  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20822  {
20823  delete [] arg1;
20824  }
20825  {
20826  delete [] arg2;
20827  }
20828  {
20829  delete [] arg3;
20830  }
20831  {
20832 
20833  }
20834  return _out;
20835 fail:
20836  {
20837  delete [] arg1;
20838  }
20839  {
20840  delete [] arg2;
20841  }
20842  {
20843  delete [] arg3;
20844  }
20845  {
20846 
20847  }
20848  return octave_value_list();
20849 }
20850 
20851 
20852 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
20853  PLINT arg1 ;
20854  int val1 ;
20855  int ecode1 = 0 ;
20856  octave_value_list _out;
20857  octave_value_list *_outp=&_out;
20858  octave_value _outv;
20859 
20860  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
20861  SWIG_fail;
20862  }
20863  ecode1 = SWIG_AsVal_int(args(0), &val1);
20864  if (!SWIG_IsOK(ecode1)) {
20865  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
20866  }
20867  arg1 = (PLINT)(val1);
20868  plscmap0n(arg1);
20869  _outv = octave_value();
20870  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20871  return _out;
20872 fail:
20873  return octave_value_list();
20874 }
20875 
20876 
20877 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
20878  PLINT *arg1 = (PLINT *) 0 ;
20879  PLINT *arg2 = (PLINT *) 0 ;
20880  PLINT *arg3 = (PLINT *) 0 ;
20881  PLINT arg4 ;
20882  Matrix temp1 ;
20883  Matrix temp2 ;
20884  Matrix temp3 ;
20885  octave_value_list _out;
20886  octave_value_list *_outp=&_out;
20887  octave_value _outv;
20888 
20889  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
20890  SWIG_fail;
20891  }
20892  {
20893  if ( _n_dims( args(0) ) > 1 )
20894  {
20895  error( "argument must be a scalar or vector" ); SWIG_fail;
20896  }
20897  Alen = (PLINT) ( _dim( args(0), 0 ) );
20898  temp1 = args(0).matrix_value();
20899  arg1 = new PLINT[Alen];
20900  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
20901  }
20902  {
20903  if ( _n_dims( args(1) ) > 1 )
20904  {
20905  error( "argument must be a scalar or vector" ); SWIG_fail;
20906  }
20907  if ( _dim( args(1), 0 ) != Alen )
20908  {
20909  error( "argument vectors must be same length" ); SWIG_fail;
20910  }
20911  temp2 = args(1).matrix_value();
20912  arg2 = new PLINT[Alen];
20913  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
20914  }
20915  {
20916  if ( _n_dims( args(2) ) > 1 )
20917  {
20918  error( "argument must be a scalar or vector" ); SWIG_fail;
20919  }
20920  if ( _dim( args(2), 0 ) != Alen )
20921  {
20922  error( "argument vectors must be same length" ); SWIG_fail;
20923  }
20924  temp3 = args(2).matrix_value();
20925  arg3 = new PLINT[Alen];
20926  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20927  arg4 = Alen;
20928  }
20929  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
20930  _outv = octave_value();
20931  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20932  {
20933  delete [] arg1;
20934  }
20935  {
20936  delete [] arg2;
20937  }
20938  {
20939  delete [] arg3;
20940  }
20941  return _out;
20942 fail:
20943  {
20944  delete [] arg1;
20945  }
20946  {
20947  delete [] arg2;
20948  }
20949  {
20950  delete [] arg3;
20951  }
20952  return octave_value_list();
20953 }
20954 
20955 
20956 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
20957  PLINT *arg1 = (PLINT *) 0 ;
20958  PLINT *arg2 = (PLINT *) 0 ;
20959  PLINT *arg3 = (PLINT *) 0 ;
20960  PLFLT *arg4 = (PLFLT *) 0 ;
20961  PLINT arg5 ;
20962  Matrix temp1 ;
20963  Matrix temp2 ;
20964  Matrix temp3 ;
20965  Matrix temp4 ;
20966  octave_value_list _out;
20967  octave_value_list *_outp=&_out;
20968  octave_value _outv;
20969 
20970  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
20971  SWIG_fail;
20972  }
20973  {
20974  if ( _n_dims( args(0) ) > 1 )
20975  {
20976  error( "argument must be a scalar or vector" ); SWIG_fail;
20977  }
20978  Alen = (PLINT) ( _dim( args(0), 0 ) );
20979  temp1 = args(0).matrix_value();
20980  arg1 = new PLINT[Alen];
20981  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
20982  }
20983  {
20984  if ( _n_dims( args(1) ) > 1 )
20985  {
20986  error( "argument must be a scalar or vector" ); SWIG_fail;
20987  }
20988  if ( _dim( args(1), 0 ) != Alen )
20989  {
20990  error( "argument vectors must be same length" ); SWIG_fail;
20991  }
20992  temp2 = args(1).matrix_value();
20993  arg2 = new PLINT[Alen];
20994  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
20995  }
20996  {
20997  if ( _n_dims( args(2) ) > 1 )
20998  {
20999  error( "argument must be a scalar or vector" ); SWIG_fail;
21000  }
21001  if ( _dim( args(2), 0 ) != Alen )
21002  {
21003  error( "argument vectors must be same length" ); SWIG_fail;
21004  }
21005  temp3 = args(2).matrix_value();
21006  arg3 = new PLINT[Alen];
21007  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21008  }
21009  {
21010  if ( _n_dims( args(3) ) > 1 )
21011  {
21012  error( "argument must be a scalar or vector" ); SWIG_fail;
21013  }
21014  if ( _dim( args(3), 0 ) != Alen )
21015  {
21016  error( "argument vectors must be same length" ); SWIG_fail;
21017  }
21018  temp4 = args(3).matrix_value();
21019  arg4 = &temp4( 0, 0 );
21020  arg5 = (PLINT) ( _dim( args(3), 0 ) );
21021  }
21022  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21023  _outv = octave_value();
21024  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21025  {
21026  delete [] arg1;
21027  }
21028  {
21029  delete [] arg2;
21030  }
21031  {
21032  delete [] arg3;
21033  }
21034  {
21035 
21036  }
21037  return _out;
21038 fail:
21039  {
21040  delete [] arg1;
21041  }
21042  {
21043  delete [] arg2;
21044  }
21045  {
21046  delete [] arg3;
21047  }
21048  {
21049 
21050  }
21051  return octave_value_list();
21052 }
21053 
21054 
21055 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
21056  PLBOOL arg1 ;
21057  PLINT arg2 ;
21058  PLFLT *arg3 = (PLFLT *) 0 ;
21059  PLFLT *arg4 = (PLFLT *) 0 ;
21060  PLFLT *arg5 = (PLFLT *) 0 ;
21061  PLFLT *arg6 = (PLFLT *) 0 ;
21062  PLBOOL *arg7 = (PLBOOL *) 0 ;
21063  int val1 ;
21064  int ecode1 = 0 ;
21065  Matrix temp2 ;
21066  Matrix temp4 ;
21067  Matrix temp5 ;
21068  Matrix temp6 ;
21069  Matrix temp7 ;
21070  octave_value_list _out;
21071  octave_value_list *_outp=&_out;
21072  octave_value _outv;
21073 
21074  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
21075  SWIG_fail;
21076  }
21077  ecode1 = SWIG_AsVal_int(args(0), &val1);
21078  if (!SWIG_IsOK(ecode1)) {
21079  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
21080  }
21081  arg1 = (PLBOOL)(val1);
21082  {
21083  if ( _n_dims( args(1) ) > 1 )
21084  {
21085  error( "argument must be a scalar or vector" ); SWIG_fail;
21086  }
21087  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21088  temp2 = args(1).matrix_value();
21089  arg3 = &temp2( 0, 0 );
21090  }
21091  {
21092  if ( _n_dims( args(2) ) > 1 )
21093  {
21094  error( "argument must be a scalar or vector" ); SWIG_fail;
21095  }
21096  if ( _dim( args(2), 0 ) != Alen )
21097  {
21098  error( "argument vectors must be same length" ); SWIG_fail;
21099  }
21100  temp4 = args(2).matrix_value();
21101  arg4 = &temp4( 0, 0 );
21102  }
21103  {
21104  if ( _n_dims( args(3) ) > 1 )
21105  {
21106  error( "argument must be a scalar or vector" ); SWIG_fail;
21107  }
21108  if ( _dim( args(3), 0 ) != Alen )
21109  {
21110  error( "argument vectors must be same length" ); SWIG_fail;
21111  }
21112  temp5 = args(3).matrix_value();
21113  arg5 = &temp5( 0, 0 );
21114  }
21115  {
21116  if ( _n_dims( args(4) ) > 1 )
21117  {
21118  error( "argument must be a scalar or vector" ); SWIG_fail;
21119  }
21120  if ( _dim( args(4), 0 ) != Alen )
21121  {
21122  error( "argument vectors must be same length" ); SWIG_fail;
21123  }
21124  temp6 = args(4).matrix_value();
21125  arg6 = &temp6( 0, 0 );
21126  }
21127  {
21128  if ( _n_dims( args(5) ) > 1 )
21129  {
21130  error( "argument must be a scalar or vector" ); SWIG_fail;
21131  }
21132  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
21133  {
21134  error( "argument vector must be same length or one less" ); SWIG_fail;
21135  }
21136  temp7 = args(5).matrix_value();
21137  arg7 = new PLINT[Alen];
21138  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
21139  }
21140  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
21141  _outv = octave_value();
21142  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21143  {
21144 
21145  }
21146  {
21147 
21148  }
21149  {
21150 
21151  }
21152  {
21153 
21154  }
21155  {
21156  delete [] arg7;
21157  }
21158  return _out;
21159 fail:
21160  {
21161 
21162  }
21163  {
21164 
21165  }
21166  {
21167 
21168  }
21169  {
21170 
21171  }
21172  {
21173  delete [] arg7;
21174  }
21175  return octave_value_list();
21176 }
21177 
21178 
21179 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
21180  PLBOOL arg1 ;
21181  PLINT arg2 ;
21182  PLFLT *arg3 = (PLFLT *) 0 ;
21183  PLFLT *arg4 = (PLFLT *) 0 ;
21184  PLFLT *arg5 = (PLFLT *) 0 ;
21185  PLFLT *arg6 = (PLFLT *) 0 ;
21186  PLFLT *arg7 = (PLFLT *) 0 ;
21187  PLBOOL *arg8 = (PLBOOL *) 0 ;
21188  int val1 ;
21189  int ecode1 = 0 ;
21190  Matrix temp2 ;
21191  Matrix temp4 ;
21192  Matrix temp5 ;
21193  Matrix temp6 ;
21194  Matrix temp7 ;
21195  Matrix temp8 ;
21196  octave_value_list _out;
21197  octave_value_list *_outp=&_out;
21198  octave_value _outv;
21199 
21200  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
21201  SWIG_fail;
21202  }
21203  ecode1 = SWIG_AsVal_int(args(0), &val1);
21204  if (!SWIG_IsOK(ecode1)) {
21205  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
21206  }
21207  arg1 = (PLBOOL)(val1);
21208  {
21209  if ( _n_dims( args(1) ) > 1 )
21210  {
21211  error( "argument must be a scalar or vector" ); SWIG_fail;
21212  }
21213  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21214  temp2 = args(1).matrix_value();
21215  arg3 = &temp2( 0, 0 );
21216  }
21217  {
21218  if ( _n_dims( args(2) ) > 1 )
21219  {
21220  error( "argument must be a scalar or vector" ); SWIG_fail;
21221  }
21222  if ( _dim( args(2), 0 ) != Alen )
21223  {
21224  error( "argument vectors must be same length" ); SWIG_fail;
21225  }
21226  temp4 = args(2).matrix_value();
21227  arg4 = &temp4( 0, 0 );
21228  }
21229  {
21230  if ( _n_dims( args(3) ) > 1 )
21231  {
21232  error( "argument must be a scalar or vector" ); SWIG_fail;
21233  }
21234  if ( _dim( args(3), 0 ) != Alen )
21235  {
21236  error( "argument vectors must be same length" ); SWIG_fail;
21237  }
21238  temp5 = args(3).matrix_value();
21239  arg5 = &temp5( 0, 0 );
21240  }
21241  {
21242  if ( _n_dims( args(4) ) > 1 )
21243  {
21244  error( "argument must be a scalar or vector" ); SWIG_fail;
21245  }
21246  if ( _dim( args(4), 0 ) != Alen )
21247  {
21248  error( "argument vectors must be same length" ); SWIG_fail;
21249  }
21250  temp6 = args(4).matrix_value();
21251  arg6 = &temp6( 0, 0 );
21252  }
21253  {
21254  if ( _n_dims( args(5) ) > 1 )
21255  {
21256  error( "argument must be a scalar or vector" ); SWIG_fail;
21257  }
21258  if ( _dim( args(5), 0 ) != Alen )
21259  {
21260  error( "argument vectors must be same length" ); SWIG_fail;
21261  }
21262  temp7 = args(5).matrix_value();
21263  arg7 = &temp7( 0, 0 );
21264  }
21265  {
21266  if ( _n_dims( args(6) ) > 1 )
21267  {
21268  error( "argument must be a scalar or vector" ); SWIG_fail;
21269  }
21270  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
21271  {
21272  error( "argument vector must be same length or one less" ); SWIG_fail;
21273  }
21274  temp8 = args(6).matrix_value();
21275  arg8 = new PLINT[Alen];
21276  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
21277  }
21278  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
21279  _outv = octave_value();
21280  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21281  {
21282 
21283  }
21284  {
21285 
21286  }
21287  {
21288 
21289  }
21290  {
21291 
21292  }
21293  {
21294 
21295  }
21296  {
21297  delete [] arg8;
21298  }
21299  return _out;
21300 fail:
21301  {
21302 
21303  }
21304  {
21305 
21306  }
21307  {
21308 
21309  }
21310  {
21311 
21312  }
21313  {
21314 
21315  }
21316  {
21317  delete [] arg8;
21318  }
21319  return octave_value_list();
21320 }
21321 
21322 
21323 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
21324  PLINT arg1 ;
21325  int val1 ;
21326  int ecode1 = 0 ;
21327  octave_value_list _out;
21328  octave_value_list *_outp=&_out;
21329  octave_value _outv;
21330 
21331  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
21332  SWIG_fail;
21333  }
21334  ecode1 = SWIG_AsVal_int(args(0), &val1);
21335  if (!SWIG_IsOK(ecode1)) {
21336  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
21337  }
21338  arg1 = (PLINT)(val1);
21339  plscmap1n(arg1);
21340  _outv = octave_value();
21341  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21342  return _out;
21343 fail:
21344  return octave_value_list();
21345 }
21346 
21347 
21348 SWIG_DEFUN( plscmap1_range, _wrap_plscmap1_range, _wrap_plscmap1_range_texinfo ) {
21349  PLFLT arg1 ;
21350  PLFLT arg2 ;
21351  double val1 ;
21352  int ecode1 = 0 ;
21353  double val2 ;
21354  int ecode2 = 0 ;
21355  octave_value_list _out;
21356  octave_value_list *_outp=&_out;
21357  octave_value _outv;
21358 
21359  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
21360  SWIG_fail;
21361  }
21362  ecode1 = SWIG_AsVal_double(args(0), &val1);
21363  if (!SWIG_IsOK(ecode1)) {
21364  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
21365  }
21366  arg1 = (PLFLT)(val1);
21367  ecode2 = SWIG_AsVal_double(args(1), &val2);
21368  if (!SWIG_IsOK(ecode2)) {
21369  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
21370  }
21371  arg2 = (PLFLT)(val2);
21372  plscmap1_range(arg1,arg2);
21373  _outv = octave_value();
21374  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21375  return _out;
21376 fail:
21377  return octave_value_list();
21378 }
21379 
21380 
21381 SWIG_DEFUN( plgcmap1_range, _wrap_plgcmap1_range, _wrap_plgcmap1_range_texinfo ) {
21382  PLFLT *arg1 = (PLFLT *) 0 ;
21383  PLFLT *arg2 = (PLFLT *) 0 ;
21384  PLFLT temp1 ;
21385  int res1 = SWIG_TMPOBJ ;
21386  PLFLT temp2 ;
21387  int res2 = SWIG_TMPOBJ ;
21388  octave_value_list _out;
21389  octave_value_list *_outp=&_out;
21390  octave_value _outv;
21391 
21392  arg1 = &temp1;
21393  arg2 = &temp2;
21394  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
21395  SWIG_fail;
21396  }
21397  plgcmap1_range(arg1,arg2);
21398  _outv = octave_value();
21399  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21400  if (SWIG_IsTmpObj(res1)) {
21401  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21402  } else {
21403  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21404  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21405  }
21406  if (SWIG_IsTmpObj(res2)) {
21407  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21408  } else {
21409  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21410  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21411  }
21412  return _out;
21413 fail:
21414  return octave_value_list();
21415 }
21416 
21417 
21418 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
21419  PLINT arg1 ;
21420  PLINT arg2 ;
21421  PLINT arg3 ;
21422  PLINT arg4 ;
21423  int val1 ;
21424  int ecode1 = 0 ;
21425  int val2 ;
21426  int ecode2 = 0 ;
21427  int val3 ;
21428  int ecode3 = 0 ;
21429  int val4 ;
21430  int ecode4 = 0 ;
21431  octave_value_list _out;
21432  octave_value_list *_outp=&_out;
21433  octave_value _outv;
21434 
21435  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
21436  SWIG_fail;
21437  }
21438  ecode1 = SWIG_AsVal_int(args(0), &val1);
21439  if (!SWIG_IsOK(ecode1)) {
21440  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
21441  }
21442  arg1 = (PLINT)(val1);
21443  ecode2 = SWIG_AsVal_int(args(1), &val2);
21444  if (!SWIG_IsOK(ecode2)) {
21445  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
21446  }
21447  arg2 = (PLINT)(val2);
21448  ecode3 = SWIG_AsVal_int(args(2), &val3);
21449  if (!SWIG_IsOK(ecode3)) {
21450  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
21451  }
21452  arg3 = (PLINT)(val3);
21453  ecode4 = SWIG_AsVal_int(args(3), &val4);
21454  if (!SWIG_IsOK(ecode4)) {
21455  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
21456  }
21457  arg4 = (PLINT)(val4);
21458  plscol0(arg1,arg2,arg3,arg4);
21459  _outv = octave_value();
21460  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21461  return _out;
21462 fail:
21463  return octave_value_list();
21464 }
21465 
21466 
21467 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
21468  PLINT arg1 ;
21469  PLINT arg2 ;
21470  PLINT arg3 ;
21471  PLINT arg4 ;
21472  PLFLT arg5 ;
21473  int val1 ;
21474  int ecode1 = 0 ;
21475  int val2 ;
21476  int ecode2 = 0 ;
21477  int val3 ;
21478  int ecode3 = 0 ;
21479  int val4 ;
21480  int ecode4 = 0 ;
21481  double val5 ;
21482  int ecode5 = 0 ;
21483  octave_value_list _out;
21484  octave_value_list *_outp=&_out;
21485  octave_value _outv;
21486 
21487  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
21488  SWIG_fail;
21489  }
21490  ecode1 = SWIG_AsVal_int(args(0), &val1);
21491  if (!SWIG_IsOK(ecode1)) {
21492  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
21493  }
21494  arg1 = (PLINT)(val1);
21495  ecode2 = SWIG_AsVal_int(args(1), &val2);
21496  if (!SWIG_IsOK(ecode2)) {
21497  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
21498  }
21499  arg2 = (PLINT)(val2);
21500  ecode3 = SWIG_AsVal_int(args(2), &val3);
21501  if (!SWIG_IsOK(ecode3)) {
21502  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
21503  }
21504  arg3 = (PLINT)(val3);
21505  ecode4 = SWIG_AsVal_int(args(3), &val4);
21506  if (!SWIG_IsOK(ecode4)) {
21507  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
21508  }
21509  arg4 = (PLINT)(val4);
21510  ecode5 = SWIG_AsVal_double(args(4), &val5);
21511  if (!SWIG_IsOK(ecode5)) {
21512  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
21513  }
21514  arg5 = (PLFLT)(val5);
21515  plscol0a(arg1,arg2,arg3,arg4,arg5);
21516  _outv = octave_value();
21517  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21518  return _out;
21519 fail:
21520  return octave_value_list();
21521 }
21522 
21523 
21524 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
21525  PLINT arg1 ;
21526  PLINT arg2 ;
21527  PLINT arg3 ;
21528  int val1 ;
21529  int ecode1 = 0 ;
21530  int val2 ;
21531  int ecode2 = 0 ;
21532  int val3 ;
21533  int ecode3 = 0 ;
21534  octave_value_list _out;
21535  octave_value_list *_outp=&_out;
21536  octave_value _outv;
21537 
21538  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
21539  SWIG_fail;
21540  }
21541  ecode1 = SWIG_AsVal_int(args(0), &val1);
21542  if (!SWIG_IsOK(ecode1)) {
21543  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
21544  }
21545  arg1 = (PLINT)(val1);
21546  ecode2 = SWIG_AsVal_int(args(1), &val2);
21547  if (!SWIG_IsOK(ecode2)) {
21548  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
21549  }
21550  arg2 = (PLINT)(val2);
21551  ecode3 = SWIG_AsVal_int(args(2), &val3);
21552  if (!SWIG_IsOK(ecode3)) {
21553  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
21554  }
21555  arg3 = (PLINT)(val3);
21556  plscolbg(arg1,arg2,arg3);
21557  _outv = octave_value();
21558  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21559  return _out;
21560 fail:
21561  return octave_value_list();
21562 }
21563 
21564 
21565 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
21566  PLINT arg1 ;
21567  PLINT arg2 ;
21568  PLINT arg3 ;
21569  PLFLT arg4 ;
21570  int val1 ;
21571  int ecode1 = 0 ;
21572  int val2 ;
21573  int ecode2 = 0 ;
21574  int val3 ;
21575  int ecode3 = 0 ;
21576  double val4 ;
21577  int ecode4 = 0 ;
21578  octave_value_list _out;
21579  octave_value_list *_outp=&_out;
21580  octave_value _outv;
21581 
21582  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
21583  SWIG_fail;
21584  }
21585  ecode1 = SWIG_AsVal_int(args(0), &val1);
21586  if (!SWIG_IsOK(ecode1)) {
21587  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
21588  }
21589  arg1 = (PLINT)(val1);
21590  ecode2 = SWIG_AsVal_int(args(1), &val2);
21591  if (!SWIG_IsOK(ecode2)) {
21592  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
21593  }
21594  arg2 = (PLINT)(val2);
21595  ecode3 = SWIG_AsVal_int(args(2), &val3);
21596  if (!SWIG_IsOK(ecode3)) {
21597  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
21598  }
21599  arg3 = (PLINT)(val3);
21600  ecode4 = SWIG_AsVal_double(args(3), &val4);
21601  if (!SWIG_IsOK(ecode4)) {
21602  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
21603  }
21604  arg4 = (PLFLT)(val4);
21605  plscolbga(arg1,arg2,arg3,arg4);
21606  _outv = octave_value();
21607  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21608  return _out;
21609 fail:
21610  return octave_value_list();
21611 }
21612 
21613 
21614 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
21615  PLINT arg1 ;
21616  int val1 ;
21617  int ecode1 = 0 ;
21618  octave_value_list _out;
21619  octave_value_list *_outp=&_out;
21620  octave_value _outv;
21621 
21622  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
21623  SWIG_fail;
21624  }
21625  ecode1 = SWIG_AsVal_int(args(0), &val1);
21626  if (!SWIG_IsOK(ecode1)) {
21627  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
21628  }
21629  arg1 = (PLINT)(val1);
21630  plscolor(arg1);
21631  _outv = octave_value();
21632  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21633  return _out;
21634 fail:
21635  return octave_value_list();
21636 }
21637 
21638 
21639 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
21640  PLINT arg1 ;
21641  int val1 ;
21642  int ecode1 = 0 ;
21643  octave_value_list _out;
21644  octave_value_list *_outp=&_out;
21645  octave_value _outv;
21646 
21647  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
21648  SWIG_fail;
21649  }
21650  ecode1 = SWIG_AsVal_int(args(0), &val1);
21651  if (!SWIG_IsOK(ecode1)) {
21652  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
21653  }
21654  arg1 = (PLINT)(val1);
21655  plscompression(arg1);
21656  _outv = octave_value();
21657  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21658  return _out;
21659 fail:
21660  return octave_value_list();
21661 }
21662 
21663 
21664 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
21665  char *arg1 = (char *) 0 ;
21666  int res1 ;
21667  char *buf1 = 0 ;
21668  int alloc1 = 0 ;
21669  octave_value_list _out;
21670  octave_value_list *_outp=&_out;
21671  octave_value _outv;
21672 
21673  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
21674  SWIG_fail;
21675  }
21676  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21677  if (!SWIG_IsOK(res1)) {
21678  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
21679  }
21680  arg1 = (char *)(buf1);
21681  plsdev((char const *)arg1);
21682  _outv = octave_value();
21683  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21684  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21685  return _out;
21686 fail:
21687  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21688  return octave_value_list();
21689 }
21690 
21691 
21692 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
21693  PLFLT arg1 ;
21694  PLFLT arg2 ;
21695  PLFLT arg3 ;
21696  PLFLT arg4 ;
21697  double val1 ;
21698  int ecode1 = 0 ;
21699  double val2 ;
21700  int ecode2 = 0 ;
21701  double val3 ;
21702  int ecode3 = 0 ;
21703  double val4 ;
21704  int ecode4 = 0 ;
21705  octave_value_list _out;
21706  octave_value_list *_outp=&_out;
21707  octave_value _outv;
21708 
21709  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
21710  SWIG_fail;
21711  }
21712  ecode1 = SWIG_AsVal_double(args(0), &val1);
21713  if (!SWIG_IsOK(ecode1)) {
21714  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
21715  }
21716  arg1 = (PLFLT)(val1);
21717  ecode2 = SWIG_AsVal_double(args(1), &val2);
21718  if (!SWIG_IsOK(ecode2)) {
21719  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
21720  }
21721  arg2 = (PLFLT)(val2);
21722  ecode3 = SWIG_AsVal_double(args(2), &val3);
21723  if (!SWIG_IsOK(ecode3)) {
21724  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
21725  }
21726  arg3 = (PLFLT)(val3);
21727  ecode4 = SWIG_AsVal_double(args(3), &val4);
21728  if (!SWIG_IsOK(ecode4)) {
21729  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
21730  }
21731  arg4 = (PLFLT)(val4);
21732  plsdidev(arg1,arg2,arg3,arg4);
21733  _outv = octave_value();
21734  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21735  return _out;
21736 fail:
21737  return octave_value_list();
21738 }
21739 
21740 
21741 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
21742  PLINT arg1 ;
21743  PLINT arg2 ;
21744  PLINT arg3 ;
21745  PLINT arg4 ;
21746  PLFLT arg5 ;
21747  PLFLT arg6 ;
21748  int val1 ;
21749  int ecode1 = 0 ;
21750  int val2 ;
21751  int ecode2 = 0 ;
21752  int val3 ;
21753  int ecode3 = 0 ;
21754  int val4 ;
21755  int ecode4 = 0 ;
21756  double val5 ;
21757  int ecode5 = 0 ;
21758  double val6 ;
21759  int ecode6 = 0 ;
21760  octave_value_list _out;
21761  octave_value_list *_outp=&_out;
21762  octave_value _outv;
21763 
21764  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
21765  SWIG_fail;
21766  }
21767  ecode1 = SWIG_AsVal_int(args(0), &val1);
21768  if (!SWIG_IsOK(ecode1)) {
21769  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
21770  }
21771  arg1 = (PLINT)(val1);
21772  ecode2 = SWIG_AsVal_int(args(1), &val2);
21773  if (!SWIG_IsOK(ecode2)) {
21774  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
21775  }
21776  arg2 = (PLINT)(val2);
21777  ecode3 = SWIG_AsVal_int(args(2), &val3);
21778  if (!SWIG_IsOK(ecode3)) {
21779  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
21780  }
21781  arg3 = (PLINT)(val3);
21782  ecode4 = SWIG_AsVal_int(args(3), &val4);
21783  if (!SWIG_IsOK(ecode4)) {
21784  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
21785  }
21786  arg4 = (PLINT)(val4);
21787  ecode5 = SWIG_AsVal_double(args(4), &val5);
21788  if (!SWIG_IsOK(ecode5)) {
21789  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
21790  }
21791  arg5 = (PLFLT)(val5);
21792  ecode6 = SWIG_AsVal_double(args(5), &val6);
21793  if (!SWIG_IsOK(ecode6)) {
21794  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
21795  }
21796  arg6 = (PLFLT)(val6);
21797  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
21798  _outv = octave_value();
21799  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21800  return _out;
21801 fail:
21802  return octave_value_list();
21803 }
21804 
21805 
21806 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
21807  PLFLT arg1 ;
21808  double val1 ;
21809  int ecode1 = 0 ;
21810  octave_value_list _out;
21811  octave_value_list *_outp=&_out;
21812  octave_value _outv;
21813 
21814  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
21815  SWIG_fail;
21816  }
21817  ecode1 = SWIG_AsVal_double(args(0), &val1);
21818  if (!SWIG_IsOK(ecode1)) {
21819  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
21820  }
21821  arg1 = (PLFLT)(val1);
21822  plsdiori(arg1);
21823  _outv = octave_value();
21824  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21825  return _out;
21826 fail:
21827  return octave_value_list();
21828 }
21829 
21830 
21831 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
21832  PLFLT arg1 ;
21833  PLFLT arg2 ;
21834  PLFLT arg3 ;
21835  PLFLT arg4 ;
21836  double val1 ;
21837  int ecode1 = 0 ;
21838  double val2 ;
21839  int ecode2 = 0 ;
21840  double val3 ;
21841  int ecode3 = 0 ;
21842  double val4 ;
21843  int ecode4 = 0 ;
21844  octave_value_list _out;
21845  octave_value_list *_outp=&_out;
21846  octave_value _outv;
21847 
21848  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
21849  SWIG_fail;
21850  }
21851  ecode1 = SWIG_AsVal_double(args(0), &val1);
21852  if (!SWIG_IsOK(ecode1)) {
21853  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
21854  }
21855  arg1 = (PLFLT)(val1);
21856  ecode2 = SWIG_AsVal_double(args(1), &val2);
21857  if (!SWIG_IsOK(ecode2)) {
21858  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
21859  }
21860  arg2 = (PLFLT)(val2);
21861  ecode3 = SWIG_AsVal_double(args(2), &val3);
21862  if (!SWIG_IsOK(ecode3)) {
21863  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
21864  }
21865  arg3 = (PLFLT)(val3);
21866  ecode4 = SWIG_AsVal_double(args(3), &val4);
21867  if (!SWIG_IsOK(ecode4)) {
21868  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
21869  }
21870  arg4 = (PLFLT)(val4);
21871  plsdiplt(arg1,arg2,arg3,arg4);
21872  _outv = octave_value();
21873  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21874  return _out;
21875 fail:
21876  return octave_value_list();
21877 }
21878 
21879 
21880 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
21881  PLFLT arg1 ;
21882  PLFLT arg2 ;
21883  PLFLT arg3 ;
21884  PLFLT arg4 ;
21885  double val1 ;
21886  int ecode1 = 0 ;
21887  double val2 ;
21888  int ecode2 = 0 ;
21889  double val3 ;
21890  int ecode3 = 0 ;
21891  double val4 ;
21892  int ecode4 = 0 ;
21893  octave_value_list _out;
21894  octave_value_list *_outp=&_out;
21895  octave_value _outv;
21896 
21897  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
21898  SWIG_fail;
21899  }
21900  ecode1 = SWIG_AsVal_double(args(0), &val1);
21901  if (!SWIG_IsOK(ecode1)) {
21902  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
21903  }
21904  arg1 = (PLFLT)(val1);
21905  ecode2 = SWIG_AsVal_double(args(1), &val2);
21906  if (!SWIG_IsOK(ecode2)) {
21907  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
21908  }
21909  arg2 = (PLFLT)(val2);
21910  ecode3 = SWIG_AsVal_double(args(2), &val3);
21911  if (!SWIG_IsOK(ecode3)) {
21912  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
21913  }
21914  arg3 = (PLFLT)(val3);
21915  ecode4 = SWIG_AsVal_double(args(3), &val4);
21916  if (!SWIG_IsOK(ecode4)) {
21917  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
21918  }
21919  arg4 = (PLFLT)(val4);
21920  plsdiplz(arg1,arg2,arg3,arg4);
21921  _outv = octave_value();
21922  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21923  return _out;
21924 fail:
21925  return octave_value_list();
21926 }
21927 
21928 
21929 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
21930  unsigned int arg1 ;
21931  unsigned int val1 ;
21932  int ecode1 = 0 ;
21933  octave_value_list _out;
21934  octave_value_list *_outp=&_out;
21935  octave_value _outv;
21936 
21937  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
21938  SWIG_fail;
21939  }
21940  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
21941  if (!SWIG_IsOK(ecode1)) {
21942  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
21943  }
21944  arg1 = (unsigned int)(val1);
21945  plseed(arg1);
21946  _outv = octave_value();
21947  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21948  return _out;
21949 fail:
21950  return octave_value_list();
21951 }
21952 
21953 
21954 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
21955  char arg1 ;
21956  char val1 ;
21957  int ecode1 = 0 ;
21958  octave_value_list _out;
21959  octave_value_list *_outp=&_out;
21960  octave_value _outv;
21961 
21962  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
21963  SWIG_fail;
21964  }
21965  ecode1 = SWIG_AsVal_char(args(0), &val1);
21966  if (!SWIG_IsOK(ecode1)) {
21967  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
21968  }
21969  arg1 = (char)(val1);
21970  plsesc(arg1);
21971  _outv = octave_value();
21972  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21973  return _out;
21974 fail:
21975  return octave_value_list();
21976 }
21977 
21978 
21979 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
21980  char *arg1 = (char *) 0 ;
21981  char *arg2 = (char *) 0 ;
21982  int res1 ;
21983  char *buf1 = 0 ;
21984  int alloc1 = 0 ;
21985  int res2 ;
21986  char *buf2 = 0 ;
21987  int alloc2 = 0 ;
21988  octave_value_list _out;
21989  octave_value_list *_outp=&_out;
21990  octave_value _outv;
21991  PLINT result;
21992 
21993  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
21994  SWIG_fail;
21995  }
21996  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21997  if (!SWIG_IsOK(res1)) {
21998  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
21999  }
22000  arg1 = (char *)(buf1);
22001  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22002  if (!SWIG_IsOK(res2)) {
22003  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
22004  }
22005  arg2 = (char *)(buf2);
22006  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
22007  _outv = SWIG_From_int((int)(result));
22008  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22009  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22010  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22011  return _out;
22012 fail:
22013  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22014  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22015  return octave_value_list();
22016 }
22017 
22018 
22019 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
22020  PLINT arg1 ;
22021  PLINT arg2 ;
22022  PLINT arg3 ;
22023  int val1 ;
22024  int ecode1 = 0 ;
22025  int val2 ;
22026  int ecode2 = 0 ;
22027  int val3 ;
22028  int ecode3 = 0 ;
22029  octave_value_list _out;
22030  octave_value_list *_outp=&_out;
22031  octave_value _outv;
22032 
22033  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
22034  SWIG_fail;
22035  }
22036  ecode1 = SWIG_AsVal_int(args(0), &val1);
22037  if (!SWIG_IsOK(ecode1)) {
22038  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
22039  }
22040  arg1 = (PLINT)(val1);
22041  ecode2 = SWIG_AsVal_int(args(1), &val2);
22042  if (!SWIG_IsOK(ecode2)) {
22043  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
22044  }
22045  arg2 = (PLINT)(val2);
22046  ecode3 = SWIG_AsVal_int(args(2), &val3);
22047  if (!SWIG_IsOK(ecode3)) {
22048  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
22049  }
22050  arg3 = (PLINT)(val3);
22051  plsfam(arg1,arg2,arg3);
22052  _outv = octave_value();
22053  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22054  return _out;
22055 fail:
22056  return octave_value_list();
22057 }
22058 
22059 
22060 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
22061  PLUNICODE arg1 ;
22062  unsigned int val1 ;
22063  int ecode1 = 0 ;
22064  octave_value_list _out;
22065  octave_value_list *_outp=&_out;
22066  octave_value _outv;
22067 
22068  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
22069  SWIG_fail;
22070  }
22071  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22072  if (!SWIG_IsOK(ecode1)) {
22073  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
22074  }
22075  arg1 = (PLUNICODE)(val1);
22076  plsfci(arg1);
22077  _outv = octave_value();
22078  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22079  return _out;
22080 fail:
22081  return octave_value_list();
22082 }
22083 
22084 
22085 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
22086  char *arg1 = (char *) 0 ;
22087  int res1 ;
22088  char *buf1 = 0 ;
22089  int alloc1 = 0 ;
22090  octave_value_list _out;
22091  octave_value_list *_outp=&_out;
22092  octave_value _outv;
22093 
22094  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
22095  SWIG_fail;
22096  }
22097  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22098  if (!SWIG_IsOK(res1)) {
22099  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
22100  }
22101  arg1 = (char *)(buf1);
22102  plsfnam((char const *)arg1);
22103  _outv = octave_value();
22104  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22105  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22106  return _out;
22107 fail:
22108  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22109  return octave_value_list();
22110 }
22111 
22112 
22113 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
22114  PLINT arg1 ;
22115  PLINT arg2 ;
22116  PLINT arg3 ;
22117  int val1 ;
22118  int ecode1 = 0 ;
22119  int val2 ;
22120  int ecode2 = 0 ;
22121  int val3 ;
22122  int ecode3 = 0 ;
22123  octave_value_list _out;
22124  octave_value_list *_outp=&_out;
22125  octave_value _outv;
22126 
22127  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
22128  SWIG_fail;
22129  }
22130  ecode1 = SWIG_AsVal_int(args(0), &val1);
22131  if (!SWIG_IsOK(ecode1)) {
22132  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
22133  }
22134  arg1 = (PLINT)(val1);
22135  ecode2 = SWIG_AsVal_int(args(1), &val2);
22136  if (!SWIG_IsOK(ecode2)) {
22137  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
22138  }
22139  arg2 = (PLINT)(val2);
22140  ecode3 = SWIG_AsVal_int(args(2), &val3);
22141  if (!SWIG_IsOK(ecode3)) {
22142  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
22143  }
22144  arg3 = (PLINT)(val3);
22145  plsfont(arg1,arg2,arg3);
22146  _outv = octave_value();
22147  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22148  return _out;
22149 fail:
22150  return octave_value_list();
22151 }
22152 
22153 
22154 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
22155  label_func arg1 = (label_func) 0 ;
22156  PLPointer arg2 = (PLPointer) 0 ;
22157  int res2 ;
22158  octave_value_list _out;
22159  octave_value_list *_outp=&_out;
22160  octave_value _outv;
22161 
22162  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
22163  SWIG_fail;
22164  }
22165  {
22166  octave_value obj = args(0);
22167  if ( !obj.is_empty() )
22168  {
22169  if ( obj.is_function_handle() || obj.is_inline_function() )
22170  {
22171  fcnLabelFunc = obj.function_value();
22172  }
22173  else if ( obj.is_string() )
22174  {
22175  nameLabelFunc = obj.string_value();
22176  fcnLabelFunc = NULL;
22177  }
22178  arg1 = labelfunc_octave;
22179  }
22180  else
22181  {
22182  arg1 = NULL;
22183  }
22184  }
22185  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
22186  if (!SWIG_IsOK(res2)) {
22187  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
22188  }
22189  plslabelfunc(arg1,arg2);
22190  _outv = octave_value();
22191  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22192  return _out;
22193 fail:
22194  return octave_value_list();
22195 }
22196 
22197 
22198 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
22199  PLFLT arg1 ;
22200  PLFLT arg2 ;
22201  double val1 ;
22202  int ecode1 = 0 ;
22203  double val2 ;
22204  int ecode2 = 0 ;
22205  octave_value_list _out;
22206  octave_value_list *_outp=&_out;
22207  octave_value _outv;
22208 
22209  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
22210  SWIG_fail;
22211  }
22212  ecode1 = SWIG_AsVal_double(args(0), &val1);
22213  if (!SWIG_IsOK(ecode1)) {
22214  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
22215  }
22216  arg1 = (PLFLT)(val1);
22217  ecode2 = SWIG_AsVal_double(args(1), &val2);
22218  if (!SWIG_IsOK(ecode2)) {
22219  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
22220  }
22221  arg2 = (PLFLT)(val2);
22222  plsmaj(arg1,arg2);
22223  _outv = octave_value();
22224  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22225  return _out;
22226 fail:
22227  return octave_value_list();
22228 }
22229 
22230 
22231 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
22232  PLFLT arg1 ;
22233  PLFLT arg2 ;
22234  double val1 ;
22235  int ecode1 = 0 ;
22236  double val2 ;
22237  int ecode2 = 0 ;
22238  octave_value_list _out;
22239  octave_value_list *_outp=&_out;
22240  octave_value _outv;
22241 
22242  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
22243  SWIG_fail;
22244  }
22245  ecode1 = SWIG_AsVal_double(args(0), &val1);
22246  if (!SWIG_IsOK(ecode1)) {
22247  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
22248  }
22249  arg1 = (PLFLT)(val1);
22250  ecode2 = SWIG_AsVal_double(args(1), &val2);
22251  if (!SWIG_IsOK(ecode2)) {
22252  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
22253  }
22254  arg2 = (PLFLT)(val2);
22255  plsmin(arg1,arg2);
22256  _outv = octave_value();
22257  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22258  return _out;
22259 fail:
22260  return octave_value_list();
22261 }
22262 
22263 
22264 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
22265  PLINT arg1 ;
22266  int val1 ;
22267  int ecode1 = 0 ;
22268  octave_value_list _out;
22269  octave_value_list *_outp=&_out;
22270  octave_value _outv;
22271 
22272  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
22273  SWIG_fail;
22274  }
22275  ecode1 = SWIG_AsVal_int(args(0), &val1);
22276  if (!SWIG_IsOK(ecode1)) {
22277  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
22278  }
22279  arg1 = (PLINT)(val1);
22280  plsori(arg1);
22281  _outv = octave_value();
22282  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22283  return _out;
22284 fail:
22285  return octave_value_list();
22286 }
22287 
22288 
22289 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
22290  PLFLT arg1 ;
22291  PLFLT arg2 ;
22292  PLINT arg3 ;
22293  PLINT arg4 ;
22294  PLINT arg5 ;
22295  PLINT arg6 ;
22296  double val1 ;
22297  int ecode1 = 0 ;
22298  double val2 ;
22299  int ecode2 = 0 ;
22300  int val3 ;
22301  int ecode3 = 0 ;
22302  int val4 ;
22303  int ecode4 = 0 ;
22304  int val5 ;
22305  int ecode5 = 0 ;
22306  int val6 ;
22307  int ecode6 = 0 ;
22308  octave_value_list _out;
22309  octave_value_list *_outp=&_out;
22310  octave_value _outv;
22311 
22312  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
22313  SWIG_fail;
22314  }
22315  ecode1 = SWIG_AsVal_double(args(0), &val1);
22316  if (!SWIG_IsOK(ecode1)) {
22317  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
22318  }
22319  arg1 = (PLFLT)(val1);
22320  ecode2 = SWIG_AsVal_double(args(1), &val2);
22321  if (!SWIG_IsOK(ecode2)) {
22322  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
22323  }
22324  arg2 = (PLFLT)(val2);
22325  ecode3 = SWIG_AsVal_int(args(2), &val3);
22326  if (!SWIG_IsOK(ecode3)) {
22327  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
22328  }
22329  arg3 = (PLINT)(val3);
22330  ecode4 = SWIG_AsVal_int(args(3), &val4);
22331  if (!SWIG_IsOK(ecode4)) {
22332  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
22333  }
22334  arg4 = (PLINT)(val4);
22335  ecode5 = SWIG_AsVal_int(args(4), &val5);
22336  if (!SWIG_IsOK(ecode5)) {
22337  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
22338  }
22339  arg5 = (PLINT)(val5);
22340  ecode6 = SWIG_AsVal_int(args(5), &val6);
22341  if (!SWIG_IsOK(ecode6)) {
22342  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
22343  }
22344  arg6 = (PLINT)(val6);
22345  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22346  _outv = octave_value();
22347  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22348  return _out;
22349 fail:
22350  return octave_value_list();
22351 }
22352 
22353 
22354 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
22355  char *arg1 = (char *) 0 ;
22356  int res1 ;
22357  char *buf1 = 0 ;
22358  int alloc1 = 0 ;
22359  octave_value_list _out;
22360  octave_value_list *_outp=&_out;
22361  octave_value _outv;
22362 
22363  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
22364  SWIG_fail;
22365  }
22366  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22367  if (!SWIG_IsOK(res1)) {
22368  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
22369  }
22370  arg1 = (char *)(buf1);
22371  plspal0((char const *)arg1);
22372  _outv = octave_value();
22373  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22374  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22375  return _out;
22376 fail:
22377  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22378  return octave_value_list();
22379 }
22380 
22381 
22382 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
22383  char *arg1 = (char *) 0 ;
22384  PLBOOL arg2 ;
22385  int res1 ;
22386  char *buf1 = 0 ;
22387  int alloc1 = 0 ;
22388  int val2 ;
22389  int ecode2 = 0 ;
22390  octave_value_list _out;
22391  octave_value_list *_outp=&_out;
22392  octave_value _outv;
22393 
22394  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
22395  SWIG_fail;
22396  }
22397  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22398  if (!SWIG_IsOK(res1)) {
22399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
22400  }
22401  arg1 = (char *)(buf1);
22402  ecode2 = SWIG_AsVal_int(args(1), &val2);
22403  if (!SWIG_IsOK(ecode2)) {
22404  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
22405  }
22406  arg2 = (PLBOOL)(val2);
22407  plspal1((char const *)arg1,arg2);
22408  _outv = octave_value();
22409  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22410  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22411  return _out;
22412 fail:
22413  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22414  return octave_value_list();
22415 }
22416 
22417 
22418 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
22419  PLBOOL arg1 ;
22420  int val1 ;
22421  int ecode1 = 0 ;
22422  octave_value_list _out;
22423  octave_value_list *_outp=&_out;
22424  octave_value _outv;
22425 
22426  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
22427  SWIG_fail;
22428  }
22429  ecode1 = SWIG_AsVal_int(args(0), &val1);
22430  if (!SWIG_IsOK(ecode1)) {
22431  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
22432  }
22433  arg1 = (PLBOOL)(val1);
22434  plspause(arg1);
22435  _outv = octave_value();
22436  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22437  return _out;
22438 fail:
22439  return octave_value_list();
22440 }
22441 
22442 
22443 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
22444  PLINT arg1 ;
22445  int val1 ;
22446  int ecode1 = 0 ;
22447  octave_value_list _out;
22448  octave_value_list *_outp=&_out;
22449  octave_value _outv;
22450 
22451  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
22452  SWIG_fail;
22453  }
22454  ecode1 = SWIG_AsVal_int(args(0), &val1);
22455  if (!SWIG_IsOK(ecode1)) {
22456  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
22457  }
22458  arg1 = (PLINT)(val1);
22459  plsstrm(arg1);
22460  _outv = octave_value();
22461  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22462  return _out;
22463 fail:
22464  return octave_value_list();
22465 }
22466 
22467 
22468 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
22469  PLINT arg1 ;
22470  PLINT arg2 ;
22471  int val1 ;
22472  int ecode1 = 0 ;
22473  int val2 ;
22474  int ecode2 = 0 ;
22475  octave_value_list _out;
22476  octave_value_list *_outp=&_out;
22477  octave_value _outv;
22478 
22479  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
22480  SWIG_fail;
22481  }
22482  ecode1 = SWIG_AsVal_int(args(0), &val1);
22483  if (!SWIG_IsOK(ecode1)) {
22484  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
22485  }
22486  arg1 = (PLINT)(val1);
22487  ecode2 = SWIG_AsVal_int(args(1), &val2);
22488  if (!SWIG_IsOK(ecode2)) {
22489  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
22490  }
22491  arg2 = (PLINT)(val2);
22492  plssub(arg1,arg2);
22493  _outv = octave_value();
22494  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22495  return _out;
22496 fail:
22497  return octave_value_list();
22498 }
22499 
22500 
22501 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
22502  PLFLT arg1 ;
22503  PLFLT arg2 ;
22504  double val1 ;
22505  int ecode1 = 0 ;
22506  double val2 ;
22507  int ecode2 = 0 ;
22508  octave_value_list _out;
22509  octave_value_list *_outp=&_out;
22510  octave_value _outv;
22511 
22512  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
22513  SWIG_fail;
22514  }
22515  ecode1 = SWIG_AsVal_double(args(0), &val1);
22516  if (!SWIG_IsOK(ecode1)) {
22517  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
22518  }
22519  arg1 = (PLFLT)(val1);
22520  ecode2 = SWIG_AsVal_double(args(1), &val2);
22521  if (!SWIG_IsOK(ecode2)) {
22522  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
22523  }
22524  arg2 = (PLFLT)(val2);
22525  plssym(arg1,arg2);
22526  _outv = octave_value();
22527  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22528  return _out;
22529 fail:
22530  return octave_value_list();
22531 }
22532 
22533 
22534 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
22535  PLINT arg1 ;
22536  PLINT arg2 ;
22537  int val1 ;
22538  int ecode1 = 0 ;
22539  int val2 ;
22540  int ecode2 = 0 ;
22541  octave_value_list _out;
22542  octave_value_list *_outp=&_out;
22543  octave_value _outv;
22544 
22545  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
22546  SWIG_fail;
22547  }
22548  ecode1 = SWIG_AsVal_int(args(0), &val1);
22549  if (!SWIG_IsOK(ecode1)) {
22550  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
22551  }
22552  arg1 = (PLINT)(val1);
22553  ecode2 = SWIG_AsVal_int(args(1), &val2);
22554  if (!SWIG_IsOK(ecode2)) {
22555  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
22556  }
22557  arg2 = (PLINT)(val2);
22558  plstar(arg1,arg2);
22559  _outv = octave_value();
22560  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22561  return _out;
22562 fail:
22563  return octave_value_list();
22564 }
22565 
22566 
22567 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
22568  char *arg1 = (char *) 0 ;
22569  PLINT arg2 ;
22570  PLINT arg3 ;
22571  int res1 ;
22572  char *buf1 = 0 ;
22573  int alloc1 = 0 ;
22574  int val2 ;
22575  int ecode2 = 0 ;
22576  int val3 ;
22577  int ecode3 = 0 ;
22578  octave_value_list _out;
22579  octave_value_list *_outp=&_out;
22580  octave_value _outv;
22581 
22582  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
22583  SWIG_fail;
22584  }
22585  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22586  if (!SWIG_IsOK(res1)) {
22587  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
22588  }
22589  arg1 = (char *)(buf1);
22590  ecode2 = SWIG_AsVal_int(args(1), &val2);
22591  if (!SWIG_IsOK(ecode2)) {
22592  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
22593  }
22594  arg2 = (PLINT)(val2);
22595  ecode3 = SWIG_AsVal_int(args(2), &val3);
22596  if (!SWIG_IsOK(ecode3)) {
22597  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
22598  }
22599  arg3 = (PLINT)(val3);
22600  plstart((char const *)arg1,arg2,arg3);
22601  _outv = octave_value();
22602  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22603  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22604  return _out;
22605 fail:
22606  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22607  return octave_value_list();
22608 }
22609 
22610 
22611 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
22612  ct_func arg1 = (ct_func) 0 ;
22613  PLPointer arg2 = (PLPointer) 0 ;
22614  int res2 ;
22615  octave_value_list _out;
22616  octave_value_list *_outp=&_out;
22617  octave_value _outv;
22618 
22619  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
22620  SWIG_fail;
22621  }
22622  {
22623  octave_value obj = args(0);
22624  if ( !obj.is_empty() )
22625  {
22626  if ( obj.is_function_handle() || obj.is_inline_function() )
22627  {
22628  fcnCoordTrans = obj.function_value();
22629  }
22630  else if ( obj.is_string() )
22631  {
22632  nameCoordTrans = obj.string_value();
22633  fcnCoordTrans = NULL;
22634  }
22635  arg1 = ct_octave;
22636  }
22637  else
22638  {
22639  arg1 = NULL;
22640  }
22641  }
22642  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
22643  if (!SWIG_IsOK(res2)) {
22644  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
22645  }
22646  plstransform(arg1,arg2);
22647  _outv = octave_value();
22648  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22649  return _out;
22650 fail:
22651  return octave_value_list();
22652 }
22653 
22654 
22655 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
22656  PLINT arg1 ;
22657  PLFLT *arg2 = (PLFLT *) 0 ;
22658  PLFLT *arg3 = (PLFLT *) 0 ;
22659  char *arg4 = (char *) 0 ;
22660  Matrix temp1 ;
22661  Matrix temp3 ;
22662  int res4 ;
22663  char *buf4 = 0 ;
22664  int alloc4 = 0 ;
22665  octave_value_list _out;
22666  octave_value_list *_outp=&_out;
22667  octave_value _outv;
22668 
22669  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
22670  SWIG_fail;
22671  }
22672  {
22673  if ( _n_dims( args(0) ) > 1 )
22674  {
22675  error( "argument must be a scalar or vector" ); SWIG_fail;
22676  }
22677  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22678  temp1 = args(0).matrix_value();
22679  arg2 = &temp1( 0, 0 );
22680  }
22681  {
22682  if ( _n_dims( args(1) ) > 1 )
22683  {
22684  error( "argument must be a scalar or vector" ); SWIG_fail;
22685  }
22686  if ( _dim( args(1), 0 ) != Alen )
22687  {
22688  error( "argument vectors must be same length" ); SWIG_fail;
22689  }
22690  temp3 = args(1).matrix_value();
22691  arg3 = &temp3( 0, 0 );
22692  }
22693  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
22694  if (!SWIG_IsOK(res4)) {
22695  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
22696  }
22697  arg4 = (char *)(buf4);
22698  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
22699  _outv = octave_value();
22700  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22701  {
22702 
22703  }
22704  {
22705 
22706  }
22707  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
22708  return _out;
22709 fail:
22710  {
22711 
22712  }
22713  {
22714 
22715  }
22716  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
22717  return octave_value_list();
22718 }
22719 
22720 
22721 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
22722  PLINT arg1 ;
22723  PLFLT *arg2 = (PLFLT *) 0 ;
22724  PLFLT *arg3 = (PLFLT *) 0 ;
22725  PLFLT *arg4 = (PLFLT *) 0 ;
22726  char *arg5 = (char *) 0 ;
22727  Matrix temp1 ;
22728  Matrix temp3 ;
22729  Matrix temp4 ;
22730  int res5 ;
22731  char *buf5 = 0 ;
22732  int alloc5 = 0 ;
22733  octave_value_list _out;
22734  octave_value_list *_outp=&_out;
22735  octave_value _outv;
22736 
22737  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
22738  SWIG_fail;
22739  }
22740  {
22741  if ( _n_dims( args(0) ) > 1 )
22742  {
22743  error( "argument must be a scalar or vector" ); SWIG_fail;
22744  }
22745  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22746  temp1 = args(0).matrix_value();
22747  arg2 = &temp1( 0, 0 );
22748  }
22749  {
22750  if ( _n_dims( args(1) ) > 1 )
22751  {
22752  error( "argument must be a scalar or vector" ); SWIG_fail;
22753  }
22754  if ( _dim( args(1), 0 ) != Alen )
22755  {
22756  error( "argument vectors must be same length" ); SWIG_fail;
22757  }
22758  temp3 = args(1).matrix_value();
22759  arg3 = &temp3( 0, 0 );
22760  }
22761  {
22762  if ( _n_dims( args(2) ) > 1 )
22763  {
22764  error( "argument must be a scalar or vector" ); SWIG_fail;
22765  }
22766  if ( _dim( args(2), 0 ) != Alen )
22767  {
22768  error( "argument vectors must be same length" ); SWIG_fail;
22769  }
22770  temp4 = args(2).matrix_value();
22771  arg4 = &temp4( 0, 0 );
22772  }
22773  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
22774  if (!SWIG_IsOK(res5)) {
22775  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
22776  }
22777  arg5 = (char *)(buf5);
22778  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
22779  _outv = octave_value();
22780  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22781  {
22782 
22783  }
22784  {
22785 
22786  }
22787  {
22788 
22789  }
22790  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
22791  return _out;
22792 fail:
22793  {
22794 
22795  }
22796  {
22797 
22798  }
22799  {
22800 
22801  }
22802  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
22803  return octave_value_list();
22804 }
22805 
22806 
22807 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
22808  PLINT arg1 ;
22809  PLINT arg2 ;
22810  PLFLT arg3 ;
22811  PLFLT arg4 ;
22812  int val1 ;
22813  int ecode1 = 0 ;
22814  int val2 ;
22815  int ecode2 = 0 ;
22816  double val3 ;
22817  int ecode3 = 0 ;
22818  double val4 ;
22819  int ecode4 = 0 ;
22820  octave_value_list _out;
22821  octave_value_list *_outp=&_out;
22822  octave_value _outv;
22823 
22824  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
22825  SWIG_fail;
22826  }
22827  ecode1 = SWIG_AsVal_int(args(0), &val1);
22828  if (!SWIG_IsOK(ecode1)) {
22829  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
22830  }
22831  arg1 = (PLINT)(val1);
22832  ecode2 = SWIG_AsVal_int(args(1), &val2);
22833  if (!SWIG_IsOK(ecode2)) {
22834  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
22835  }
22836  arg2 = (PLINT)(val2);
22837  ecode3 = SWIG_AsVal_double(args(2), &val3);
22838  if (!SWIG_IsOK(ecode3)) {
22839  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
22840  }
22841  arg3 = (PLFLT)(val3);
22842  ecode4 = SWIG_AsVal_double(args(3), &val4);
22843  if (!SWIG_IsOK(ecode4)) {
22844  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
22845  }
22846  arg4 = (PLFLT)(val4);
22847  plstripa(arg1,arg2,arg3,arg4);
22848  _outv = octave_value();
22849  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22850  return _out;
22851 fail:
22852  return octave_value_list();
22853 }
22854 
22855 
22856 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
22857  PLINT arg1 ;
22858  int val1 ;
22859  int ecode1 = 0 ;
22860  octave_value_list _out;
22861  octave_value_list *_outp=&_out;
22862  octave_value _outv;
22863 
22864  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
22865  SWIG_fail;
22866  }
22867  ecode1 = SWIG_AsVal_int(args(0), &val1);
22868  if (!SWIG_IsOK(ecode1)) {
22869  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
22870  }
22871  arg1 = (PLINT)(val1);
22872  plstripd(arg1);
22873  _outv = octave_value();
22874  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22875  return _out;
22876 fail:
22877  return octave_value_list();
22878 }
22879 
22880 
22881 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
22882  PLINT arg1 ;
22883  PLINT *arg2 = (PLINT *) 0 ;
22884  PLINT *arg3 = (PLINT *) 0 ;
22885  Matrix temp1 ;
22886  Matrix temp3 ;
22887  octave_value_list _out;
22888  octave_value_list *_outp=&_out;
22889  octave_value _outv;
22890 
22891  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
22892  SWIG_fail;
22893  }
22894  {
22895  if ( _n_dims( args(0) ) > 1 )
22896  {
22897  error( "argument must be a scalar or vector" ); SWIG_fail;
22898  }
22899  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
22900  arg2 = new PLINT[Alen];
22901  temp1 = args(0).matrix_value();
22902  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
22903  }
22904  {
22905  if ( _n_dims( args(1) ) > 1 )
22906  {
22907  error( "argument must be a scalar or vector" ); SWIG_fail;
22908  }
22909  if ( _dim( args(1), 0 ) != Alen )
22910  {
22911  error( "argument vectors must be same length" ); SWIG_fail;
22912  }
22913  temp3 = args(1).matrix_value();
22914  arg3 = new PLINT[Alen];
22915  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22916  }
22917  plstyl(arg1,(int const *)arg2,(int const *)arg3);
22918  _outv = octave_value();
22919  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22920  {
22921  delete [] arg2;
22922  }
22923  {
22924  delete [] arg3;
22925  }
22926  return _out;
22927 fail:
22928  {
22929  delete [] arg2;
22930  }
22931  {
22932  delete [] arg3;
22933  }
22934  return octave_value_list();
22935 }
22936 
22937 
22938 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
22939  PLFLT *arg1 = (PLFLT *) 0 ;
22940  PLFLT *arg2 = (PLFLT *) 0 ;
22941  PLINT arg3 ;
22942  PLBOOL arg4 ;
22943  Matrix temp1 ;
22944  Matrix temp2 ;
22945  int val4 ;
22946  int ecode4 = 0 ;
22947  octave_value_list _out;
22948  octave_value_list *_outp=&_out;
22949  octave_value _outv;
22950 
22951  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
22952  SWIG_fail;
22953  }
22954  {
22955  if ( _n_dims( args(0) ) > 1 )
22956  {
22957  error( "argument must be a scalar or vector" ); SWIG_fail;
22958  }
22959  if ( !args(0).is_empty() )
22960  {
22961  Alen = (PLINT) ( _dim( args(0), 0 ) );
22962  temp1 = args(0).matrix_value();
22963  arg1 = &temp1( 0, 0 );
22964  }
22965  else
22966  {
22967  arg1 = NULL;
22968  Alen = 0;
22969  }
22970  }
22971  {
22972  if ( _n_dims( args(1) ) > 1 )
22973  {
22974  error( "argument must be a scalar or vector" ); SWIG_fail;
22975  }
22976  if ( !args(1).is_empty() )
22977  {
22978  if ( _dim( args(1), 0 ) != Alen )
22979  {
22980  error( "argument vectors must be same length" ); SWIG_fail;
22981  }
22982  temp2 = args(1).matrix_value();
22983  arg2 = &temp2( 0, 0 );
22984  arg3 = (PLINT) ( _dim( args(1), 0 ) );
22985  }
22986  else
22987  {
22988  arg2 = NULL;
22989  arg3 = 0;
22990  }
22991  }
22992  ecode4 = SWIG_AsVal_int(args(2), &val4);
22993  if (!SWIG_IsOK(ecode4)) {
22994  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
22995  }
22996  arg4 = (PLBOOL)(val4);
22997  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
22998  _outv = octave_value();
22999  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23000  {
23001 
23002  }
23003  {
23004 
23005  }
23006  return _out;
23007 fail:
23008  {
23009 
23010  }
23011  {
23012 
23013  }
23014  return octave_value_list();
23015 }
23016 
23017 
23018 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
23019  PLFLT arg1 ;
23020  PLFLT arg2 ;
23021  PLFLT arg3 ;
23022  PLFLT arg4 ;
23023  double val1 ;
23024  int ecode1 = 0 ;
23025  double val2 ;
23026  int ecode2 = 0 ;
23027  double val3 ;
23028  int ecode3 = 0 ;
23029  double val4 ;
23030  int ecode4 = 0 ;
23031  octave_value_list _out;
23032  octave_value_list *_outp=&_out;
23033  octave_value _outv;
23034 
23035  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
23036  SWIG_fail;
23037  }
23038  ecode1 = SWIG_AsVal_double(args(0), &val1);
23039  if (!SWIG_IsOK(ecode1)) {
23040  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
23041  }
23042  arg1 = (PLFLT)(val1);
23043  ecode2 = SWIG_AsVal_double(args(1), &val2);
23044  if (!SWIG_IsOK(ecode2)) {
23045  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
23046  }
23047  arg2 = (PLFLT)(val2);
23048  ecode3 = SWIG_AsVal_double(args(2), &val3);
23049  if (!SWIG_IsOK(ecode3)) {
23050  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
23051  }
23052  arg3 = (PLFLT)(val3);
23053  ecode4 = SWIG_AsVal_double(args(3), &val4);
23054  if (!SWIG_IsOK(ecode4)) {
23055  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
23056  }
23057  arg4 = (PLFLT)(val4);
23058  plsvpa(arg1,arg2,arg3,arg4);
23059  _outv = octave_value();
23060  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23061  return _out;
23062 fail:
23063  return octave_value_list();
23064 }
23065 
23066 
23067 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
23068  PLINT arg1 ;
23069  PLINT arg2 ;
23070  int val1 ;
23071  int ecode1 = 0 ;
23072  int val2 ;
23073  int ecode2 = 0 ;
23074  octave_value_list _out;
23075  octave_value_list *_outp=&_out;
23076  octave_value _outv;
23077 
23078  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
23079  SWIG_fail;
23080  }
23081  ecode1 = SWIG_AsVal_int(args(0), &val1);
23082  if (!SWIG_IsOK(ecode1)) {
23083  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
23084  }
23085  arg1 = (PLINT)(val1);
23086  ecode2 = SWIG_AsVal_int(args(1), &val2);
23087  if (!SWIG_IsOK(ecode2)) {
23088  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
23089  }
23090  arg2 = (PLINT)(val2);
23091  plsxax(arg1,arg2);
23092  _outv = octave_value();
23093  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23094  return _out;
23095 fail:
23096  return octave_value_list();
23097 }
23098 
23099 
23100 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
23101  PLINT arg1 ;
23102  PLINT arg2 ;
23103  int val1 ;
23104  int ecode1 = 0 ;
23105  int val2 ;
23106  int ecode2 = 0 ;
23107  octave_value_list _out;
23108  octave_value_list *_outp=&_out;
23109  octave_value _outv;
23110 
23111  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
23112  SWIG_fail;
23113  }
23114  ecode1 = SWIG_AsVal_int(args(0), &val1);
23115  if (!SWIG_IsOK(ecode1)) {
23116  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
23117  }
23118  arg1 = (PLINT)(val1);
23119  ecode2 = SWIG_AsVal_int(args(1), &val2);
23120  if (!SWIG_IsOK(ecode2)) {
23121  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
23122  }
23123  arg2 = (PLINT)(val2);
23124  plsyax(arg1,arg2);
23125  _outv = octave_value();
23126  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23127  return _out;
23128 fail:
23129  return octave_value_list();
23130 }
23131 
23132 
23133 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
23134  PLINT arg1 ;
23135  PLFLT *arg2 = (PLFLT *) 0 ;
23136  PLFLT *arg3 = (PLFLT *) 0 ;
23137  PLINT arg4 ;
23138  Matrix temp1 ;
23139  Matrix temp3 ;
23140  int val4 ;
23141  int ecode4 = 0 ;
23142  octave_value_list _out;
23143  octave_value_list *_outp=&_out;
23144  octave_value _outv;
23145 
23146  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
23147  SWIG_fail;
23148  }
23149  {
23150  if ( _n_dims( args(0) ) > 1 )
23151  {
23152  error( "argument must be a scalar or vector" ); SWIG_fail;
23153  }
23154  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23155  temp1 = args(0).matrix_value();
23156  arg2 = &temp1( 0, 0 );
23157  }
23158  {
23159  if ( _n_dims( args(1) ) > 1 )
23160  {
23161  error( "argument must be a scalar or vector" ); SWIG_fail;
23162  }
23163  if ( _dim( args(1), 0 ) != Alen )
23164  {
23165  error( "argument vectors must be same length" ); SWIG_fail;
23166  }
23167  temp3 = args(1).matrix_value();
23168  arg3 = &temp3( 0, 0 );
23169  }
23170  ecode4 = SWIG_AsVal_int(args(2), &val4);
23171  if (!SWIG_IsOK(ecode4)) {
23172  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
23173  }
23174  arg4 = (PLINT)(val4);
23175  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
23176  _outv = octave_value();
23177  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23178  {
23179 
23180  }
23181  {
23182 
23183  }
23184  return _out;
23185 fail:
23186  {
23187 
23188  }
23189  {
23190 
23191  }
23192  return octave_value_list();
23193 }
23194 
23195 
23196 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
23197  PLINT arg1 ;
23198  PLINT arg2 ;
23199  int val1 ;
23200  int ecode1 = 0 ;
23201  int val2 ;
23202  int ecode2 = 0 ;
23203  octave_value_list _out;
23204  octave_value_list *_outp=&_out;
23205  octave_value _outv;
23206 
23207  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
23208  SWIG_fail;
23209  }
23210  ecode1 = SWIG_AsVal_int(args(0), &val1);
23211  if (!SWIG_IsOK(ecode1)) {
23212  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
23213  }
23214  arg1 = (PLINT)(val1);
23215  ecode2 = SWIG_AsVal_int(args(1), &val2);
23216  if (!SWIG_IsOK(ecode2)) {
23217  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
23218  }
23219  arg2 = (PLINT)(val2);
23220  plszax(arg1,arg2);
23221  _outv = octave_value();
23222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23223  return _out;
23224 fail:
23225  return octave_value_list();
23226 }
23227 
23228 
23229 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
23230  octave_value_list _out;
23231  octave_value_list *_outp=&_out;
23232  octave_value _outv;
23233 
23234  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
23235  SWIG_fail;
23236  }
23237  pltext();
23238  _outv = octave_value();
23239  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23240  return _out;
23241 fail:
23242  return octave_value_list();
23243 }
23244 
23245 
23246 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
23247  char *arg1 = (char *) 0 ;
23248  int res1 ;
23249  char *buf1 = 0 ;
23250  int alloc1 = 0 ;
23251  octave_value_list _out;
23252  octave_value_list *_outp=&_out;
23253  octave_value _outv;
23254 
23255  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
23256  SWIG_fail;
23257  }
23258  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23259  if (!SWIG_IsOK(res1)) {
23260  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
23261  }
23262  arg1 = (char *)(buf1);
23263  pltimefmt((char const *)arg1);
23264  _outv = octave_value();
23265  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23266  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23267  return _out;
23268 fail:
23269  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23270  return octave_value_list();
23271 }
23272 
23273 
23274 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
23275  PLFLT arg1 ;
23276  double val1 ;
23277  int ecode1 = 0 ;
23278  octave_value_list _out;
23279  octave_value_list *_outp=&_out;
23280  octave_value _outv;
23281 
23282  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
23283  SWIG_fail;
23284  }
23285  ecode1 = SWIG_AsVal_double(args(0), &val1);
23286  if (!SWIG_IsOK(ecode1)) {
23287  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
23288  }
23289  arg1 = (PLFLT)(val1);
23290  plvasp(arg1);
23291  _outv = octave_value();
23292  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23293  return _out;
23294 fail:
23295  return octave_value_list();
23296 }
23297 
23298 
23299 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
23300  PLFLT arg1 ;
23301  PLFLT arg2 ;
23302  PLFLT arg3 ;
23303  PLFLT arg4 ;
23304  PLFLT arg5 ;
23305  double val1 ;
23306  int ecode1 = 0 ;
23307  double val2 ;
23308  int ecode2 = 0 ;
23309  double val3 ;
23310  int ecode3 = 0 ;
23311  double val4 ;
23312  int ecode4 = 0 ;
23313  double val5 ;
23314  int ecode5 = 0 ;
23315  octave_value_list _out;
23316  octave_value_list *_outp=&_out;
23317  octave_value _outv;
23318 
23319  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
23320  SWIG_fail;
23321  }
23322  ecode1 = SWIG_AsVal_double(args(0), &val1);
23323  if (!SWIG_IsOK(ecode1)) {
23324  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
23325  }
23326  arg1 = (PLFLT)(val1);
23327  ecode2 = SWIG_AsVal_double(args(1), &val2);
23328  if (!SWIG_IsOK(ecode2)) {
23329  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
23330  }
23331  arg2 = (PLFLT)(val2);
23332  ecode3 = SWIG_AsVal_double(args(2), &val3);
23333  if (!SWIG_IsOK(ecode3)) {
23334  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
23335  }
23336  arg3 = (PLFLT)(val3);
23337  ecode4 = SWIG_AsVal_double(args(3), &val4);
23338  if (!SWIG_IsOK(ecode4)) {
23339  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
23340  }
23341  arg4 = (PLFLT)(val4);
23342  ecode5 = SWIG_AsVal_double(args(4), &val5);
23343  if (!SWIG_IsOK(ecode5)) {
23344  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
23345  }
23346  arg5 = (PLFLT)(val5);
23347  plvpas(arg1,arg2,arg3,arg4,arg5);
23348  _outv = octave_value();
23349  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23350  return _out;
23351 fail:
23352  return octave_value_list();
23353 }
23354 
23355 
23356 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
23357  PLFLT arg1 ;
23358  PLFLT arg2 ;
23359  PLFLT arg3 ;
23360  PLFLT arg4 ;
23361  double val1 ;
23362  int ecode1 = 0 ;
23363  double val2 ;
23364  int ecode2 = 0 ;
23365  double val3 ;
23366  int ecode3 = 0 ;
23367  double val4 ;
23368  int ecode4 = 0 ;
23369  octave_value_list _out;
23370  octave_value_list *_outp=&_out;
23371  octave_value _outv;
23372 
23373  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
23374  SWIG_fail;
23375  }
23376  ecode1 = SWIG_AsVal_double(args(0), &val1);
23377  if (!SWIG_IsOK(ecode1)) {
23378  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
23379  }
23380  arg1 = (PLFLT)(val1);
23381  ecode2 = SWIG_AsVal_double(args(1), &val2);
23382  if (!SWIG_IsOK(ecode2)) {
23383  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
23384  }
23385  arg2 = (PLFLT)(val2);
23386  ecode3 = SWIG_AsVal_double(args(2), &val3);
23387  if (!SWIG_IsOK(ecode3)) {
23388  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
23389  }
23390  arg3 = (PLFLT)(val3);
23391  ecode4 = SWIG_AsVal_double(args(3), &val4);
23392  if (!SWIG_IsOK(ecode4)) {
23393  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
23394  }
23395  arg4 = (PLFLT)(val4);
23396  plvpor(arg1,arg2,arg3,arg4);
23397  _outv = octave_value();
23398  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23399  return _out;
23400 fail:
23401  return octave_value_list();
23402 }
23403 
23404 
23405 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
23406  octave_value_list _out;
23407  octave_value_list *_outp=&_out;
23408  octave_value _outv;
23409 
23410  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
23411  SWIG_fail;
23412  }
23413  plvsta();
23414  _outv = octave_value();
23415  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23416  return _out;
23417 fail:
23418  return octave_value_list();
23419 }
23420 
23421 
23422 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
23423  PLFLT arg1 ;
23424  PLFLT arg2 ;
23425  PLFLT arg3 ;
23426  PLFLT arg4 ;
23427  PLFLT arg5 ;
23428  PLFLT arg6 ;
23429  PLFLT arg7 ;
23430  PLFLT arg8 ;
23431  PLFLT arg9 ;
23432  PLFLT arg10 ;
23433  PLFLT arg11 ;
23434  double val1 ;
23435  int ecode1 = 0 ;
23436  double val2 ;
23437  int ecode2 = 0 ;
23438  double val3 ;
23439  int ecode3 = 0 ;
23440  double val4 ;
23441  int ecode4 = 0 ;
23442  double val5 ;
23443  int ecode5 = 0 ;
23444  double val6 ;
23445  int ecode6 = 0 ;
23446  double val7 ;
23447  int ecode7 = 0 ;
23448  double val8 ;
23449  int ecode8 = 0 ;
23450  double val9 ;
23451  int ecode9 = 0 ;
23452  double val10 ;
23453  int ecode10 = 0 ;
23454  double val11 ;
23455  int ecode11 = 0 ;
23456  octave_value_list _out;
23457  octave_value_list *_outp=&_out;
23458  octave_value _outv;
23459 
23460  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
23461  SWIG_fail;
23462  }
23463  ecode1 = SWIG_AsVal_double(args(0), &val1);
23464  if (!SWIG_IsOK(ecode1)) {
23465  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
23466  }
23467  arg1 = (PLFLT)(val1);
23468  ecode2 = SWIG_AsVal_double(args(1), &val2);
23469  if (!SWIG_IsOK(ecode2)) {
23470  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
23471  }
23472  arg2 = (PLFLT)(val2);
23473  ecode3 = SWIG_AsVal_double(args(2), &val3);
23474  if (!SWIG_IsOK(ecode3)) {
23475  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
23476  }
23477  arg3 = (PLFLT)(val3);
23478  ecode4 = SWIG_AsVal_double(args(3), &val4);
23479  if (!SWIG_IsOK(ecode4)) {
23480  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
23481  }
23482  arg4 = (PLFLT)(val4);
23483  ecode5 = SWIG_AsVal_double(args(4), &val5);
23484  if (!SWIG_IsOK(ecode5)) {
23485  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
23486  }
23487  arg5 = (PLFLT)(val5);
23488  ecode6 = SWIG_AsVal_double(args(5), &val6);
23489  if (!SWIG_IsOK(ecode6)) {
23490  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
23491  }
23492  arg6 = (PLFLT)(val6);
23493  ecode7 = SWIG_AsVal_double(args(6), &val7);
23494  if (!SWIG_IsOK(ecode7)) {
23495  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
23496  }
23497  arg7 = (PLFLT)(val7);
23498  ecode8 = SWIG_AsVal_double(args(7), &val8);
23499  if (!SWIG_IsOK(ecode8)) {
23500  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
23501  }
23502  arg8 = (PLFLT)(val8);
23503  ecode9 = SWIG_AsVal_double(args(8), &val9);
23504  if (!SWIG_IsOK(ecode9)) {
23505  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
23506  }
23507  arg9 = (PLFLT)(val9);
23508  ecode10 = SWIG_AsVal_double(args(9), &val10);
23509  if (!SWIG_IsOK(ecode10)) {
23510  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
23511  }
23512  arg10 = (PLFLT)(val10);
23513  ecode11 = SWIG_AsVal_double(args(10), &val11);
23514  if (!SWIG_IsOK(ecode11)) {
23515  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
23516  }
23517  arg11 = (PLFLT)(val11);
23518  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23519  _outv = octave_value();
23520  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23521  return _out;
23522 fail:
23523  return octave_value_list();
23524 }
23525 
23526 
23527 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
23528  PLFLT arg1 ;
23529  double val1 ;
23530  int ecode1 = 0 ;
23531  octave_value_list _out;
23532  octave_value_list *_outp=&_out;
23533  octave_value _outv;
23534 
23535  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
23536  SWIG_fail;
23537  }
23538  ecode1 = SWIG_AsVal_double(args(0), &val1);
23539  if (!SWIG_IsOK(ecode1)) {
23540  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
23541  }
23542  arg1 = (PLFLT)(val1);
23543  plwidth(arg1);
23544  _outv = octave_value();
23545  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23546  return _out;
23547 fail:
23548  return octave_value_list();
23549 }
23550 
23551 
23552 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
23553  PLFLT arg1 ;
23554  PLFLT arg2 ;
23555  PLFLT arg3 ;
23556  PLFLT arg4 ;
23557  double val1 ;
23558  int ecode1 = 0 ;
23559  double val2 ;
23560  int ecode2 = 0 ;
23561  double val3 ;
23562  int ecode3 = 0 ;
23563  double val4 ;
23564  int ecode4 = 0 ;
23565  octave_value_list _out;
23566  octave_value_list *_outp=&_out;
23567  octave_value _outv;
23568 
23569  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
23570  SWIG_fail;
23571  }
23572  ecode1 = SWIG_AsVal_double(args(0), &val1);
23573  if (!SWIG_IsOK(ecode1)) {
23574  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
23575  }
23576  arg1 = (PLFLT)(val1);
23577  ecode2 = SWIG_AsVal_double(args(1), &val2);
23578  if (!SWIG_IsOK(ecode2)) {
23579  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
23580  }
23581  arg2 = (PLFLT)(val2);
23582  ecode3 = SWIG_AsVal_double(args(2), &val3);
23583  if (!SWIG_IsOK(ecode3)) {
23584  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
23585  }
23586  arg3 = (PLFLT)(val3);
23587  ecode4 = SWIG_AsVal_double(args(3), &val4);
23588  if (!SWIG_IsOK(ecode4)) {
23589  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
23590  }
23591  arg4 = (PLFLT)(val4);
23592  plwind(arg1,arg2,arg3,arg4);
23593  _outv = octave_value();
23594  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23595  return _out;
23596 fail:
23597  return octave_value_list();
23598 }
23599 
23600 
23601 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
23602  PLBOOL arg1 ;
23603  PLBOOL *arg2 = (PLBOOL *) 0 ;
23604  int val1 ;
23605  int ecode1 = 0 ;
23606  PLBOOL temp2 ;
23607  int res2 = SWIG_TMPOBJ ;
23608  octave_value_list _out;
23609  octave_value_list *_outp=&_out;
23610  octave_value _outv;
23611 
23612  arg2 = &temp2;
23613  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
23614  SWIG_fail;
23615  }
23616  ecode1 = SWIG_AsVal_int(args(0), &val1);
23617  if (!SWIG_IsOK(ecode1)) {
23618  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
23619  }
23620  arg1 = (PLBOOL)(val1);
23621  plxormod(arg1,arg2);
23622  _outv = octave_value();
23623  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23624  if (SWIG_IsTmpObj(res2)) {
23625  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
23626  } else {
23627  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23628  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
23629  }
23630  return _out;
23631 fail:
23632  return octave_value_list();
23633 }
23634 
23635 
23636 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
23637  mapform_func arg1 = (mapform_func) 0 ;
23638  char *arg2 = (char *) 0 ;
23639  PLFLT arg3 ;
23640  PLFLT arg4 ;
23641  PLFLT arg5 ;
23642  PLFLT arg6 ;
23643  int res2 ;
23644  char *buf2 = 0 ;
23645  int alloc2 = 0 ;
23646  double val3 ;
23647  int ecode3 = 0 ;
23648  double val4 ;
23649  int ecode4 = 0 ;
23650  double val5 ;
23651  int ecode5 = 0 ;
23652  double val6 ;
23653  int ecode6 = 0 ;
23654  octave_value_list _out;
23655  octave_value_list *_outp=&_out;
23656  octave_value _outv;
23657 
23658  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
23659  SWIG_fail;
23660  }
23661  {
23662  octave_value obj = args(0);
23663  if ( !obj.is_empty() )
23664  {
23665  if ( obj.is_function_handle() || obj.is_inline_function() )
23666  {
23667  fcnMapForm = obj.function_value();
23668  }
23669  else if ( obj.is_string() )
23670  {
23671  nameMapForm = obj.string_value();
23672  fcnMapForm = NULL;
23673  }
23674  arg1 = mapform_octave;
23675  }
23676  else
23677  {
23678  arg1 = NULL;
23679  }
23680  }
23681  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23682  if (!SWIG_IsOK(res2)) {
23683  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
23684  }
23685  arg2 = (char *)(buf2);
23686  ecode3 = SWIG_AsVal_double(args(2), &val3);
23687  if (!SWIG_IsOK(ecode3)) {
23688  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
23689  }
23690  arg3 = (PLFLT)(val3);
23691  ecode4 = SWIG_AsVal_double(args(3), &val4);
23692  if (!SWIG_IsOK(ecode4)) {
23693  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
23694  }
23695  arg4 = (PLFLT)(val4);
23696  ecode5 = SWIG_AsVal_double(args(4), &val5);
23697  if (!SWIG_IsOK(ecode5)) {
23698  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
23699  }
23700  arg5 = (PLFLT)(val5);
23701  ecode6 = SWIG_AsVal_double(args(5), &val6);
23702  if (!SWIG_IsOK(ecode6)) {
23703  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
23704  }
23705  arg6 = (PLFLT)(val6);
23706  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
23707  _outv = octave_value();
23708  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23709  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23710  return _out;
23711 fail:
23712  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23713  return octave_value_list();
23714 }
23715 
23716 
23717 SWIG_DEFUN( plmapline, _wrap_plmapline, _wrap_plmapline_texinfo ) {
23718  mapform_func arg1 = (mapform_func) 0 ;
23719  char *arg2 = (char *) 0 ;
23720  PLFLT arg3 ;
23721  PLFLT arg4 ;
23722  PLFLT arg5 ;
23723  PLFLT arg6 ;
23724  PLINT *arg7 = (PLINT *) 0 ;
23725  PLINT arg8 ;
23726  int res2 ;
23727  char *buf2 = 0 ;
23728  int alloc2 = 0 ;
23729  double val3 ;
23730  int ecode3 = 0 ;
23731  double val4 ;
23732  int ecode4 = 0 ;
23733  double val5 ;
23734  int ecode5 = 0 ;
23735  double val6 ;
23736  int ecode6 = 0 ;
23737  Matrix temp7 ;
23738  octave_value_list _out;
23739  octave_value_list *_outp=&_out;
23740  octave_value _outv;
23741 
23742  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
23743  SWIG_fail;
23744  }
23745  {
23746  octave_value obj = args(0);
23747  if ( !obj.is_empty() )
23748  {
23749  if ( obj.is_function_handle() || obj.is_inline_function() )
23750  {
23751  fcnMapForm = obj.function_value();
23752  }
23753  else if ( obj.is_string() )
23754  {
23755  nameMapForm = obj.string_value();
23756  fcnMapForm = NULL;
23757  }
23758  arg1 = mapform_octave;
23759  }
23760  else
23761  {
23762  arg1 = NULL;
23763  }
23764  }
23765  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23766  if (!SWIG_IsOK(res2)) {
23767  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
23768  }
23769  arg2 = (char *)(buf2);
23770  ecode3 = SWIG_AsVal_double(args(2), &val3);
23771  if (!SWIG_IsOK(ecode3)) {
23772  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
23773  }
23774  arg3 = (PLFLT)(val3);
23775  ecode4 = SWIG_AsVal_double(args(3), &val4);
23776  if (!SWIG_IsOK(ecode4)) {
23777  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
23778  }
23779  arg4 = (PLFLT)(val4);
23780  ecode5 = SWIG_AsVal_double(args(4), &val5);
23781  if (!SWIG_IsOK(ecode5)) {
23782  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
23783  }
23784  arg5 = (PLFLT)(val5);
23785  ecode6 = SWIG_AsVal_double(args(5), &val6);
23786  if (!SWIG_IsOK(ecode6)) {
23787  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
23788  }
23789  arg6 = (PLFLT)(val6);
23790  {
23791  if ( _n_dims( args(6) ) > 1 )
23792  {
23793  error( "argument must be a scalar or vector" ); SWIG_fail;
23794  }
23795  if ( !args(6).is_empty() )
23796  {
23797  arg8 = (PLINT) ( _dim( args(6), 0 ) );
23798  temp7 = args(6).matrix_value();
23799  arg7 = new PLINT[arg8];
23800  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
23801  }
23802  else
23803  {
23804  arg7 = NULL;
23805  arg8 = 0;
23806  }
23807  }
23808  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
23809  _outv = octave_value();
23810  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23811  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23812  {
23813  delete [] arg7;
23814  }
23815  return _out;
23816 fail:
23817  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23818  {
23819  delete [] arg7;
23820  }
23821  return octave_value_list();
23822 }
23823 
23824 
23825 SWIG_DEFUN( plmapstring, _wrap_plmapstring, _wrap_plmapstring_texinfo ) {
23826  mapform_func arg1 = (mapform_func) 0 ;
23827  char *arg2 = (char *) 0 ;
23828  char *arg3 = (char *) 0 ;
23829  PLFLT arg4 ;
23830  PLFLT arg5 ;
23831  PLFLT arg6 ;
23832  PLFLT arg7 ;
23833  PLINT *arg8 = (PLINT *) 0 ;
23834  PLINT arg9 ;
23835  int res2 ;
23836  char *buf2 = 0 ;
23837  int alloc2 = 0 ;
23838  int res3 ;
23839  char *buf3 = 0 ;
23840  int alloc3 = 0 ;
23841  double val4 ;
23842  int ecode4 = 0 ;
23843  double val5 ;
23844  int ecode5 = 0 ;
23845  double val6 ;
23846  int ecode6 = 0 ;
23847  double val7 ;
23848  int ecode7 = 0 ;
23849  Matrix temp8 ;
23850  octave_value_list _out;
23851  octave_value_list *_outp=&_out;
23852  octave_value _outv;
23853 
23854  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
23855  SWIG_fail;
23856  }
23857  {
23858  octave_value obj = args(0);
23859  if ( !obj.is_empty() )
23860  {
23861  if ( obj.is_function_handle() || obj.is_inline_function() )
23862  {
23863  fcnMapForm = obj.function_value();
23864  }
23865  else if ( obj.is_string() )
23866  {
23867  nameMapForm = obj.string_value();
23868  fcnMapForm = NULL;
23869  }
23870  arg1 = mapform_octave;
23871  }
23872  else
23873  {
23874  arg1 = NULL;
23875  }
23876  }
23877  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23878  if (!SWIG_IsOK(res2)) {
23879  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
23880  }
23881  arg2 = (char *)(buf2);
23882  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
23883  if (!SWIG_IsOK(res3)) {
23884  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
23885  }
23886  arg3 = (char *)(buf3);
23887  ecode4 = SWIG_AsVal_double(args(3), &val4);
23888  if (!SWIG_IsOK(ecode4)) {
23889  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
23890  }
23891  arg4 = (PLFLT)(val4);
23892  ecode5 = SWIG_AsVal_double(args(4), &val5);
23893  if (!SWIG_IsOK(ecode5)) {
23894  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
23895  }
23896  arg5 = (PLFLT)(val5);
23897  ecode6 = SWIG_AsVal_double(args(5), &val6);
23898  if (!SWIG_IsOK(ecode6)) {
23899  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
23900  }
23901  arg6 = (PLFLT)(val6);
23902  ecode7 = SWIG_AsVal_double(args(6), &val7);
23903  if (!SWIG_IsOK(ecode7)) {
23904  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
23905  }
23906  arg7 = (PLFLT)(val7);
23907  {
23908  if ( _n_dims( args(7) ) > 1 )
23909  {
23910  error( "argument must be a scalar or vector" ); SWIG_fail;
23911  }
23912  if ( !args(7).is_empty() )
23913  {
23914  arg9 = (PLINT) ( _dim( args(7), 0 ) );
23915  temp8 = args(7).matrix_value();
23916  arg8 = new PLINT[arg9];
23917  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
23918  }
23919  else
23920  {
23921  arg8 = NULL;
23922  arg9 = 0;
23923  }
23924  }
23925  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
23926  _outv = octave_value();
23927  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23928  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23929  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
23930  {
23931  delete [] arg8;
23932  }
23933  return _out;
23934 fail:
23935  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23936  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
23937  {
23938  delete [] arg8;
23939  }
23940  return octave_value_list();
23941 }
23942 
23943 
23944 SWIG_DEFUN( plmaptex, _wrap_plmaptex, _wrap_plmaptex_texinfo ) {
23945  mapform_func arg1 = (mapform_func) 0 ;
23946  char *arg2 = (char *) 0 ;
23947  PLFLT arg3 ;
23948  PLFLT arg4 ;
23949  PLFLT arg5 ;
23950  char *arg6 = (char *) 0 ;
23951  PLFLT arg7 ;
23952  PLFLT arg8 ;
23953  PLFLT arg9 ;
23954  PLFLT arg10 ;
23955  PLINT arg11 ;
23956  int res2 ;
23957  char *buf2 = 0 ;
23958  int alloc2 = 0 ;
23959  double val3 ;
23960  int ecode3 = 0 ;
23961  double val4 ;
23962  int ecode4 = 0 ;
23963  double val5 ;
23964  int ecode5 = 0 ;
23965  int res6 ;
23966  char *buf6 = 0 ;
23967  int alloc6 = 0 ;
23968  double val7 ;
23969  int ecode7 = 0 ;
23970  double val8 ;
23971  int ecode8 = 0 ;
23972  double val9 ;
23973  int ecode9 = 0 ;
23974  double val10 ;
23975  int ecode10 = 0 ;
23976  int val11 ;
23977  int ecode11 = 0 ;
23978  octave_value_list _out;
23979  octave_value_list *_outp=&_out;
23980  octave_value _outv;
23981 
23982  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
23983  SWIG_fail;
23984  }
23985  {
23986  octave_value obj = args(0);
23987  if ( !obj.is_empty() )
23988  {
23989  if ( obj.is_function_handle() || obj.is_inline_function() )
23990  {
23991  fcnMapForm = obj.function_value();
23992  }
23993  else if ( obj.is_string() )
23994  {
23995  nameMapForm = obj.string_value();
23996  fcnMapForm = NULL;
23997  }
23998  arg1 = mapform_octave;
23999  }
24000  else
24001  {
24002  arg1 = NULL;
24003  }
24004  }
24005  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24006  if (!SWIG_IsOK(res2)) {
24007  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
24008  }
24009  arg2 = (char *)(buf2);
24010  ecode3 = SWIG_AsVal_double(args(2), &val3);
24011  if (!SWIG_IsOK(ecode3)) {
24012  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
24013  }
24014  arg3 = (PLFLT)(val3);
24015  ecode4 = SWIG_AsVal_double(args(3), &val4);
24016  if (!SWIG_IsOK(ecode4)) {
24017  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
24018  }
24019  arg4 = (PLFLT)(val4);
24020  ecode5 = SWIG_AsVal_double(args(4), &val5);
24021  if (!SWIG_IsOK(ecode5)) {
24022  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
24023  }
24024  arg5 = (PLFLT)(val5);
24025  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
24026  if (!SWIG_IsOK(res6)) {
24027  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
24028  }
24029  arg6 = (char *)(buf6);
24030  ecode7 = SWIG_AsVal_double(args(6), &val7);
24031  if (!SWIG_IsOK(ecode7)) {
24032  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
24033  }
24034  arg7 = (PLFLT)(val7);
24035  ecode8 = SWIG_AsVal_double(args(7), &val8);
24036  if (!SWIG_IsOK(ecode8)) {
24037  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
24038  }
24039  arg8 = (PLFLT)(val8);
24040  ecode9 = SWIG_AsVal_double(args(8), &val9);
24041  if (!SWIG_IsOK(ecode9)) {
24042  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
24043  }
24044  arg9 = (PLFLT)(val9);
24045  ecode10 = SWIG_AsVal_double(args(9), &val10);
24046  if (!SWIG_IsOK(ecode10)) {
24047  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
24048  }
24049  arg10 = (PLFLT)(val10);
24050  ecode11 = SWIG_AsVal_int(args(10), &val11);
24051  if (!SWIG_IsOK(ecode11)) {
24052  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
24053  }
24054  arg11 = (PLINT)(val11);
24055  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24056  _outv = octave_value();
24057  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24058  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24059  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24060  return _out;
24061 fail:
24062  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24063  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24064  return octave_value_list();
24065 }
24066 
24067 
24068 SWIG_DEFUN( plmapfill, _wrap_plmapfill, _wrap_plmapfill_texinfo ) {
24069  mapform_func arg1 = (mapform_func) 0 ;
24070  char *arg2 = (char *) 0 ;
24071  PLFLT arg3 ;
24072  PLFLT arg4 ;
24073  PLFLT arg5 ;
24074  PLFLT arg6 ;
24075  PLINT *arg7 = (PLINT *) 0 ;
24076  PLINT arg8 ;
24077  int res2 ;
24078  char *buf2 = 0 ;
24079  int alloc2 = 0 ;
24080  double val3 ;
24081  int ecode3 = 0 ;
24082  double val4 ;
24083  int ecode4 = 0 ;
24084  double val5 ;
24085  int ecode5 = 0 ;
24086  double val6 ;
24087  int ecode6 = 0 ;
24088  Matrix temp7 ;
24089  octave_value_list _out;
24090  octave_value_list *_outp=&_out;
24091  octave_value _outv;
24092 
24093  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
24094  SWIG_fail;
24095  }
24096  {
24097  octave_value obj = args(0);
24098  if ( !obj.is_empty() )
24099  {
24100  if ( obj.is_function_handle() || obj.is_inline_function() )
24101  {
24102  fcnMapForm = obj.function_value();
24103  }
24104  else if ( obj.is_string() )
24105  {
24106  nameMapForm = obj.string_value();
24107  fcnMapForm = NULL;
24108  }
24109  arg1 = mapform_octave;
24110  }
24111  else
24112  {
24113  arg1 = NULL;
24114  }
24115  }
24116  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24117  if (!SWIG_IsOK(res2)) {
24118  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
24119  }
24120  arg2 = (char *)(buf2);
24121  ecode3 = SWIG_AsVal_double(args(2), &val3);
24122  if (!SWIG_IsOK(ecode3)) {
24123  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
24124  }
24125  arg3 = (PLFLT)(val3);
24126  ecode4 = SWIG_AsVal_double(args(3), &val4);
24127  if (!SWIG_IsOK(ecode4)) {
24128  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
24129  }
24130  arg4 = (PLFLT)(val4);
24131  ecode5 = SWIG_AsVal_double(args(4), &val5);
24132  if (!SWIG_IsOK(ecode5)) {
24133  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
24134  }
24135  arg5 = (PLFLT)(val5);
24136  ecode6 = SWIG_AsVal_double(args(5), &val6);
24137  if (!SWIG_IsOK(ecode6)) {
24138  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
24139  }
24140  arg6 = (PLFLT)(val6);
24141  {
24142  if ( _n_dims( args(6) ) > 1 )
24143  {
24144  error( "argument must be a scalar or vector" ); SWIG_fail;
24145  }
24146  if ( !args(6).is_empty() )
24147  {
24148  arg8 = (PLINT) ( _dim( args(6), 0 ) );
24149  temp7 = args(6).matrix_value();
24150  arg7 = new PLINT[arg8];
24151  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24152  }
24153  else
24154  {
24155  arg7 = NULL;
24156  arg8 = 0;
24157  }
24158  }
24159  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24160  _outv = octave_value();
24161  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24162  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24163  {
24164  delete [] arg7;
24165  }
24166  return _out;
24167 fail:
24168  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24169  {
24170  delete [] arg7;
24171  }
24172  return octave_value_list();
24173 }
24174 
24175 
24176 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
24177  mapform_func arg1 = (mapform_func) 0 ;
24178  PLFLT arg2 ;
24179  PLFLT arg3 ;
24180  PLFLT arg4 ;
24181  PLFLT arg5 ;
24182  PLFLT arg6 ;
24183  PLFLT arg7 ;
24184  double val2 ;
24185  int ecode2 = 0 ;
24186  double val3 ;
24187  int ecode3 = 0 ;
24188  double val4 ;
24189  int ecode4 = 0 ;
24190  double val5 ;
24191  int ecode5 = 0 ;
24192  double val6 ;
24193  int ecode6 = 0 ;
24194  double val7 ;
24195  int ecode7 = 0 ;
24196  octave_value_list _out;
24197  octave_value_list *_outp=&_out;
24198  octave_value _outv;
24199 
24200  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
24201  SWIG_fail;
24202  }
24203  {
24204  octave_value obj = args(0);
24205  if ( !obj.is_empty() )
24206  {
24207  if ( obj.is_function_handle() || obj.is_inline_function() )
24208  {
24209  fcnMapForm = obj.function_value();
24210  }
24211  else if ( obj.is_string() )
24212  {
24213  nameMapForm = obj.string_value();
24214  fcnMapForm = NULL;
24215  }
24216  arg1 = mapform_octave;
24217  }
24218  else
24219  {
24220  arg1 = NULL;
24221  }
24222  }
24223  ecode2 = SWIG_AsVal_double(args(1), &val2);
24224  if (!SWIG_IsOK(ecode2)) {
24225  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
24226  }
24227  arg2 = (PLFLT)(val2);
24228  ecode3 = SWIG_AsVal_double(args(2), &val3);
24229  if (!SWIG_IsOK(ecode3)) {
24230  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
24231  }
24232  arg3 = (PLFLT)(val3);
24233  ecode4 = SWIG_AsVal_double(args(3), &val4);
24234  if (!SWIG_IsOK(ecode4)) {
24235  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
24236  }
24237  arg4 = (PLFLT)(val4);
24238  ecode5 = SWIG_AsVal_double(args(4), &val5);
24239  if (!SWIG_IsOK(ecode5)) {
24240  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
24241  }
24242  arg5 = (PLFLT)(val5);
24243  ecode6 = SWIG_AsVal_double(args(5), &val6);
24244  if (!SWIG_IsOK(ecode6)) {
24245  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
24246  }
24247  arg6 = (PLFLT)(val6);
24248  ecode7 = SWIG_AsVal_double(args(6), &val7);
24249  if (!SWIG_IsOK(ecode7)) {
24250  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
24251  }
24252  arg7 = (PLFLT)(val7);
24253  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24254  _outv = octave_value();
24255  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24256  return _out;
24257 fail:
24258  return octave_value_list();
24259 }
24260 
24261 
24263  octave_value_list _out;
24264  octave_value_list *_outp=&_out;
24265  octave_value _outv;
24266 
24267  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
24268  SWIG_fail;
24269  }
24270  plClearOpts();
24271  _outv = octave_value();
24272  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24273  return _out;
24274 fail:
24275  return octave_value_list();
24276 }
24277 
24278 
24280  octave_value_list _out;
24281  octave_value_list *_outp=&_out;
24282  octave_value _outv;
24283 
24284  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
24285  SWIG_fail;
24286  }
24287  plResetOpts();
24288  _outv = octave_value();
24289  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24290  return _out;
24291 fail:
24292  return octave_value_list();
24293 }
24294 
24295 
24297  char *arg1 = (char *) 0 ;
24298  char *arg2 = (char *) 0 ;
24299  int res1 ;
24300  char *buf1 = 0 ;
24301  int alloc1 = 0 ;
24302  int res2 ;
24303  char *buf2 = 0 ;
24304  int alloc2 = 0 ;
24305  octave_value_list _out;
24306  octave_value_list *_outp=&_out;
24307  octave_value _outv;
24308 
24309  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
24310  SWIG_fail;
24311  }
24312  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24313  if (!SWIG_IsOK(res1)) {
24314  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
24315  }
24316  arg1 = (char *)(buf1);
24317  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24318  if (!SWIG_IsOK(res2)) {
24319  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
24320  }
24321  arg2 = (char *)(buf2);
24322  plSetUsage((char const *)arg1,(char const *)arg2);
24323  _outv = octave_value();
24324  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24325  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24326  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24327  return _out;
24328 fail:
24329  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24330  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24331  return octave_value_list();
24332 }
24333 
24334 
24336  octave_value_list _out;
24337  octave_value_list *_outp=&_out;
24338  octave_value _outv;
24339 
24340  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
24341  SWIG_fail;
24342  }
24343  plOptUsage();
24344  _outv = octave_value();
24345  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24346  return _out;
24347 fail:
24348  return octave_value_list();
24349 }
24350 
24351 
24352 
24353 static const struct swig_octave_member swig_globals[] = {
24354 {"testppchar",_wrap_testppchar,0,0,2,0},
24355 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
24356 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24357 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
24358 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
24359 {"plcont0",_wrap_plcont0,0,0,2,0},
24360 {"plcont1",_wrap_plcont1,0,0,2,0},
24361 {"plcont2",_wrap_plcont2,0,0,2,0},
24362 {"plcont2p",_wrap_plcont2p,0,0,2,0},
24363 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
24364 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
24365 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
24366 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
24367 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
24368 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
24369 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
24370 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
24371 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
24372 {"plshade1",_wrap_plshade1,0,0,2,0},
24373 {"plshade2",_wrap_plshade2,0,0,2,0},
24374 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
24375 {"plshadesx",_wrap_plshadesx,0,0,2,0},
24376 {"plshades1",_wrap_plshades1,0,0,2,0},
24377 {"plshades2",_wrap_plshades2,0,0,2,0},
24378 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
24379 {"plvect1",_wrap_plvect1,0,0,2,0},
24380 {"plvect2",_wrap_plvect2,0,0,2,0},
24381 {"pplimage",_wrap_pplimage,0,0,2,0},
24382 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
24383 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24384 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24385 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24386 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
24387 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
24388 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
24389 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
24390 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
24391 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
24392 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
24393 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
24394 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
24395 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
24396 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
24397 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
24398 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
24399 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
24400 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
24401 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
24402 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
24403 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
24404 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
24405 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
24406 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
24407 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
24408 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
24409 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
24410 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
24411 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
24412 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
24413 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
24414 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
24415 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
24416 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
24417 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
24418 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
24419 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
24420 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
24421 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
24422 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
24423 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
24424 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
24425 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
24426 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
24427 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
24428 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
24429 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
24430 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
24431 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
24432 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
24433 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
24434 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
24435 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
24436 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
24437 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
24438 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
24439 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
24440 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
24441 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
24442 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
24443 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
24444 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
24445 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
24446 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
24447 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
24448 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
24449 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
24450 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
24451 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
24452 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
24453 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
24454 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
24455 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
24456 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
24457 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
24458 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
24459 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
24460 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
24461 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
24462 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
24463 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
24464 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
24465 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
24466 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
24467 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
24468 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
24469 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
24470 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
24471 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
24472 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
24473 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
24474 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
24475 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
24476 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
24477 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
24478 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
24479 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
24480 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
24481 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
24482 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
24483 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
24484 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
24485 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
24486 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
24487 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
24488 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
24489 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
24490 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
24491 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
24492 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
24493 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
24494 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
24495 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
24496 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
24497 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
24498 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
24499 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
24500 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
24501 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
24502 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
24503 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
24504 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
24505 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
24506 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
24507 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
24508 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
24509 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
24510 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
24511 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
24512 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
24513 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
24514 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
24515 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
24516 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
24517 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
24518 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
24519 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
24520 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
24521 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
24522 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
24523 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
24524 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
24525 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
24526 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
24527 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
24528 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
24529 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
24530 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
24531 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
24532 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
24533 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
24534 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
24535 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
24536 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
24537 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
24538 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
24539 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
24540 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
24541 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
24542 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
24543 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
24544 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
24545 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
24546 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
24547 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
24548 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
24549 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
24550 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
24551 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
24552 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
24553 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
24554 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
24555 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
24556 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
24557 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
24558 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
24559 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
24560 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
24561 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
24562 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
24563 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
24564 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
24565 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
24566 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
24567 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
24568 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
24569 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
24570 {0,0,0,0,0}
24571 };
24572 
24573 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
24574 
24575 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
24576 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
24577 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
24578 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};
24579 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};
24580 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};
24581 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
24582 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
24583 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
24584 
24587  &_swigt__p_char,
24592  &_swigt__p_int,
24595 };
24596 
24597 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
24598 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
24599 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
24603 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
24604 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
24605 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
24606 
24614  _swigc__p_int,
24617 };
24618 
24619 
24620 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
24621 
24622 /* -----------------------------------------------------------------------------
24623  * Type initialization:
24624  * This problem is tough by the requirement that no dynamic
24625  * memory is used. Also, since swig_type_info structures store pointers to
24626  * swig_cast_info structures and swig_cast_info structures store pointers back
24627  * to swig_type_info structures, we need some lookup code at initialization.
24628  * The idea is that swig generates all the structures that are needed.
24629  * The runtime then collects these partially filled structures.
24630  * The SWIG_InitializeModule function takes these initial arrays out of
24631  * swig_module, and does all the lookup, filling in the swig_module.types
24632  * array with the correct data and linking the correct swig_cast_info
24633  * structures together.
24634  *
24635  * The generated swig_type_info structures are assigned staticly to an initial
24636  * array. We just loop through that array, and handle each type individually.
24637  * First we lookup if this type has been already loaded, and if so, use the
24638  * loaded structure instead of the generated one. Then we have to fill in the
24639  * cast linked list. The cast data is initially stored in something like a
24640  * two-dimensional array. Each row corresponds to a type (there are the same
24641  * number of rows as there are in the swig_type_initial array). Each entry in
24642  * a column is one of the swig_cast_info structures for that type.
24643  * The cast_initial array is actually an array of arrays, because each row has
24644  * a variable number of columns. So to actually build the cast linked list,
24645  * we find the array of casts associated with the type, and loop through it
24646  * adding the casts to the list. The one last trick we need to do is making
24647  * sure the type pointer in the swig_cast_info struct is correct.
24648  *
24649  * First off, we lookup the cast->type name to see if it is already loaded.
24650  * There are three cases to handle:
24651  * 1) If the cast->type has already been loaded AND the type we are adding
24652  * casting info to has not been loaded (it is in this module), THEN we
24653  * replace the cast->type pointer with the type pointer that has already
24654  * been loaded.
24655  * 2) If BOTH types (the one we are adding casting info to, and the
24656  * cast->type) are loaded, THEN the cast info has already been loaded by
24657  * the previous module so we just ignore it.
24658  * 3) Finally, if cast->type has not already been loaded, then we add that
24659  * swig_cast_info to the linked list (because the cast->type) pointer will
24660  * be correct.
24661  * ----------------------------------------------------------------------------- */
24662 
24663 #ifdef __cplusplus
24664 extern "C" {
24665 #if 0
24666 } /* c-mode */
24667 #endif
24668 #endif
24669 
24670 #if 0
24671 #define SWIGRUNTIME_DEBUG
24672 #endif
24673 
24674 
24675 SWIGRUNTIME void
24676 SWIG_InitializeModule(void *clientdata) {
24677  size_t i;
24678  swig_module_info *module_head, *iter;
24679  int found, init;
24680 
24681  /* check to see if the circular list has been setup, if not, set it up */
24682  if (swig_module.next==0) {
24683  /* Initialize the swig_module */
24684  swig_module.type_initial = swig_type_initial;
24685  swig_module.cast_initial = swig_cast_initial;
24686  swig_module.next = &swig_module;
24687  init = 1;
24688  } else {
24689  init = 0;
24690  }
24691 
24692  /* Try and load any already created modules */
24693  module_head = SWIG_GetModule(clientdata);
24694  if (!module_head) {
24695  /* This is the first module loaded for this interpreter */
24696  /* so set the swig module into the interpreter */
24697  SWIG_SetModule(clientdata, &swig_module);
24698  module_head = &swig_module;
24699  } else {
24700  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
24701  found=0;
24702  iter=module_head;
24703  do {
24704  if (iter==&swig_module) {
24705  found=1;
24706  break;
24707  }
24708  iter=iter->next;
24709  } while (iter!= module_head);
24710 
24711  /* if the is found in the list, then all is done and we may leave */
24712  if (found) return;
24713  /* otherwise we must add out module into the list */
24714  swig_module.next = module_head->next;
24715  module_head->next = &swig_module;
24716  }
24717 
24718  /* When multiple interpreters are used, a module could have already been initialized in
24719  a different interpreter, but not yet have a pointer in this interpreter.
24720  In this case, we do not want to continue adding types... everything should be
24721  set up already */
24722  if (init == 0) return;
24723 
24724  /* Now work on filling in swig_module.types */
24725 #ifdef SWIGRUNTIME_DEBUG
24726  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
24727 #endif
24728  for (i = 0; i < swig_module.size; ++i) {
24729  swig_type_info *type = 0;
24730  swig_type_info *ret;
24731  swig_cast_info *cast;
24732 
24733 #ifdef SWIGRUNTIME_DEBUG
24734  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24735 #endif
24736 
24737  /* if there is another module already loaded */
24738  if (swig_module.next != &swig_module) {
24739  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
24740  }
24741  if (type) {
24742  /* Overwrite clientdata field */
24743 #ifdef SWIGRUNTIME_DEBUG
24744  printf("SWIG_InitializeModule: found type %s\n", type->name);
24745 #endif
24746  if (swig_module.type_initial[i]->clientdata) {
24747  type->clientdata = swig_module.type_initial[i]->clientdata;
24748 #ifdef SWIGRUNTIME_DEBUG
24749  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
24750 #endif
24751  }
24752  } else {
24753  type = swig_module.type_initial[i];
24754  }
24755 
24756  /* Insert casting types */
24757  cast = swig_module.cast_initial[i];
24758  while (cast->type) {
24759 
24760  /* Don't need to add information already in the list */
24761  ret = 0;
24762 #ifdef SWIGRUNTIME_DEBUG
24763  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
24764 #endif
24765  if (swig_module.next != &swig_module) {
24766  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
24767 #ifdef SWIGRUNTIME_DEBUG
24768  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
24769 #endif
24770  }
24771  if (ret) {
24772  if (type == swig_module.type_initial[i]) {
24773 #ifdef SWIGRUNTIME_DEBUG
24774  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
24775 #endif
24776  cast->type = ret;
24777  ret = 0;
24778  } else {
24779  /* Check for casting already in the list */
24780  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
24781 #ifdef SWIGRUNTIME_DEBUG
24782  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
24783 #endif
24784  if (!ocast) ret = 0;
24785  }
24786  }
24787 
24788  if (!ret) {
24789 #ifdef SWIGRUNTIME_DEBUG
24790  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
24791 #endif
24792  if (type->cast) {
24793  type->cast->prev = cast;
24794  cast->next = type->cast;
24795  }
24796  type->cast = cast;
24797  }
24798  cast++;
24799  }
24800  /* Set entry in modules->types array equal to the type */
24801  swig_module.types[i] = type;
24802  }
24803  swig_module.types[i] = 0;
24804 
24805 #ifdef SWIGRUNTIME_DEBUG
24806  printf("**** SWIG_InitializeModule: Cast List ******\n");
24807  for (i = 0; i < swig_module.size; ++i) {
24808  int j = 0;
24809  swig_cast_info *cast = swig_module.cast_initial[i];
24810  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
24811  while (cast->type) {
24812  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
24813  cast++;
24814  ++j;
24815  }
24816  printf("---- Total casts: %d\n",j);
24817  }
24818  printf("**** SWIG_InitializeModule: Cast List ******\n");
24819 #endif
24820 }
24821 
24822 /* This function will propagate the clientdata field of type to
24823 * any new swig_type_info structures that have been added into the list
24824 * of equivalent types. It is like calling
24825 * SWIG_TypeClientData(type, clientdata) a second time.
24826 */
24827 SWIGRUNTIME void
24829  size_t i;
24830  swig_cast_info *equiv;
24831  static int init_run = 0;
24832 
24833  if (init_run) return;
24834  init_run = 1;
24835 
24836  for (i = 0; i < swig_module.size; i++) {
24837  if (swig_module.types[i]->clientdata) {
24838  equiv = swig_module.types[i]->cast;
24839  while (equiv) {
24840  if (!equiv->converter) {
24841  if (equiv->type && !equiv->type->clientdata)
24842  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
24843  }
24844  equiv = equiv->next;
24845  }
24846  }
24847  }
24848 }
24849 
24850 #ifdef __cplusplus
24851 #if 0
24852 { /* c-mode */
24853 #endif
24854 }
24855 #endif
24856 
24857 
24858 
24859 static bool SWIG_init_user(octave_swig_type* module_ns);
24860 
24862  bool retn;
24863  {
24864 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24865  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
24866  unwind_protect_int(error_state);
24867  unwind_protect_int(warning_state);
24868  unwind_protect_bool(discard_error_messages);
24869  unwind_protect_bool(discard_warning_messages);
24870 #else
24871  unwind_protect frame;
24872  frame.protect_var(error_state);
24873  frame.protect_var(warning_state);
24874  frame.protect_var(discard_error_messages);
24875  frame.protect_var(discard_warning_messages);
24876 #endif
24877  error_state = 0;
24878  warning_state = 0;
24879  discard_error_messages = true;
24880  discard_warning_messages = true;
24881  feval(name, octave_value_list(), 0);
24882  retn = (error_state == 0);
24883 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24884  unwind_protect::run_frame("SWIG_Octave_LoadModule");
24885 #endif
24886  }
24887  if (!retn) {
24888  error(SWIG_name_d ": could not load module `%s'", name.c_str());
24889  }
24890  return retn;
24891 }
24892 
24893 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
24894  bool retn;
24895  {
24896 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24897  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
24898  unwind_protect_int(error_state);
24899  unwind_protect_int(warning_state);
24900  unwind_protect_bool(discard_error_messages);
24901  unwind_protect_bool(discard_warning_messages);
24902 #else
24903  unwind_protect frame;
24904  frame.protect_var(error_state);
24905  frame.protect_var(warning_state);
24906  frame.protect_var(discard_error_messages);
24907  frame.protect_var(discard_warning_messages);
24908 #endif
24909  error_state = 0;
24910  warning_state = 0;
24911  discard_error_messages = true;
24912  discard_warning_messages = true;
24913  octave_value_list args;
24914  args.append(name);
24915  args.append(octloadfcn->fcn_file_name());
24916  error_state = 0;
24917  feval("autoload", args, 0);
24918  retn = (error_state == 0);
24919 #if !SWIG_OCTAVE_PREREQ(3,3,50)
24920  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
24921 #endif
24922  }
24923  if (!retn) {
24924  error(SWIG_name_d ": could not load function `%s'", name.c_str());
24925  }
24926  return retn;
24927 }
24928 
24929 static const char *const subclass_usage = "-*- texinfo -*- \n\
24930 @deftypefn {Loadable Function} {} subclass()\n\
24931 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
24932 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
24933 \n\
24934 See the SWIG manual for usage examples.\n\
24935 @end deftypefn";
24936 
24937 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
24939  for (int j = 0; j < args.length(); ++j) {
24940  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
24941  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
24942  octave_swig_type *ost = osr->get_ptr();
24943  if (!ost->is_owned()) {
24944  error("subclass: cannot subclass object not constructed on octave side");
24945  return octave_value_list();
24946  }
24947  top->merge(*ost);
24948  } else if (args(j).is_function_handle()) {
24949  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
24950  } else if (args(j).is_string()) {
24951  if (j + 1 >= args.length()) {
24952  error("subclass: member assignments must be of string,value form");
24953  return octave_value_list();
24954  }
24955  top->assign(args(j).string_value(), args(j + 1));
24956  ++j;
24957  } else {
24958  error("subclass: invalid arguments to subclass()");
24959  return octave_value_list();
24960  }
24961  }
24962  return octave_value(Swig::swig_value_ref(top));
24963 }
24964 
24965 static const char *const swig_type_usage = "-*- texinfo -*- \n\
24966 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
24967 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
24968 @end deftypefn";
24969 
24970 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
24971  if (args.length() != 1) {
24972  error("swig_type: must be called with only a single object");
24973  return octave_value_list();
24974  }
24975  octave_swig_type *ost = Swig::swig_value_deref(args(0));
24976  if (!ost) {
24977  error("swig_type: object is not a swig_ref");
24978  return octave_value_list();
24979  }
24980  return octave_value(ost->swig_type_name());
24981 }
24982 
24983 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
24984 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
24985 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
24986 otherwise return `<unknown>'.\n\
24987 @end deftypefn";
24988 
24989 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
24990  if (args.length() != 1 || !args(0).is_string()) {
24991  error("swig_typequery: must be called with single string argument");
24992  return octave_value_list();
24993  }
24994  swig_module_info *module = SWIG_GetModule(0);
24995  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
24996  if (!type)
24997  return octave_value("<unknown>");
24998  return octave_value(type->name);
24999 }
25000 
25001 static const char *const swig_this_usage = "-*- texinfo -*- \n\
25002 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25003 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25004 @end deftypefn";
25005 
25006 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
25007  if (args.length() != 1) {
25008  error("swig_this: must be called with only a single object");
25009  return octave_value_list();
25010  }
25011  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25012  return octave_value(octave_uint64(0));
25013  octave_swig_type *ost = Swig::swig_value_deref(args(0));
25014  if (!ost) {
25015  error("swig_this: object is not a swig_ref");
25016  return octave_value_list();
25017  }
25018  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
25019 }
25020 
25021 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
25022 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25023 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25024 @end deftypefn";
25025 
25026 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
25027 
25028  static octave_swig_type* module_ns = 0;
25029 
25030  // workaround to prevent octave seg-faulting on exit: set Octave exit function
25031  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
25032  // definitely affects version 3.2.*, not sure about 3.3.*, seems to be fixed in
25033  // version 3.4.* and above. can be turned off with macro definition.
25034 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25035 #if SWIG_OCTAVE_PREREQ(3,2,0) && !SWIG_OCTAVE_PREREQ(3,4,1)
25036  octave_exit = ::_Exit;
25037 #endif
25038 #endif
25039 
25040  // check for no input and output args
25041  if (args.length() != 0 || nargout != 0) {
25042  print_usage();
25043  return octave_value_list();
25044  }
25045 
25046  // create module on first function call
25047  if (!module_ns) {
25048 
25049  // workaround bug in octave where installing global variable of custom type and then
25050  // exiting without explicitly clearing the variable causes octave to segfault.
25051 #if SWIG_OCTAVE_PREREQ(3,2,0)
25052  octave_value_list eval_args;
25053  eval_args.append("base");
25054  eval_args.append("function __swig_atexit__; "
25055  " if mislocked() "
25056  " clear -all; "
25057  " else "
25058  " mlock(); "
25059  " endif; "
25060  "endfunction; "
25061  "__swig_atexit__; "
25062  "atexit(\"__swig_atexit__\", false); "
25063  "atexit(\"__swig_atexit__\")");
25064  feval("evalin", eval_args, 0);
25065 #endif
25066 
25067  octave_swig_ref::register_type();
25068  octave_swig_packed::register_type();
25071 
25072  octave_function *me = octave_call_stack::current();
25073 
25074  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
25075  return octave_value_list();
25076  }
25077  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
25078  return octave_value_list();
25079  }
25080  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
25081  return octave_value_list();
25082  }
25083  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
25084  return octave_value_list();
25085  }
25086 
25087  octave_swig_type* cvar_ns=0;
25088  if (std::string(SWIG_global_name) != ".") {
25089  cvar_ns=new octave_swig_type;
25090  for (int j=0;swig_globals[j].name;++j)
25091  if (swig_globals[j].get_method)
25092  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
25093  }
25094 
25095  module_ns=new octave_swig_type(0, 0, 0, true);
25096  if (std::string(SWIG_global_name) != ".") {
25097  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
25098  }
25099  else {
25100  for (int j=0;swig_globals[j].name;++j)
25101  if (swig_globals[j].get_method)
25102  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25103  }
25104  for (int j=0;swig_globals[j].name;++j)
25105  if (swig_globals[j].method)
25106  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25107 
25108  // * need better solution here; swig_type -> octave_class mapping is
25109  // * really n-to-1, in some cases such as template partial spec, etc.
25110  // * see failing tests.
25111  for (int j=0;swig_types[j];++j)
25112  if (swig_types[j]->clientdata) {
25113  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
25114  module_ns->assign(c->name,
25116  (new octave_swig_type(0,swig_types[j])));
25117  }
25118 
25119  if (!SWIG_init_user(module_ns)) {
25120  delete module_ns;
25121  module_ns=0;
25122  return octave_value_list();
25123  }
25124 
25125  SWIG_InstallOps(octave_swig_ref::static_type_id());
25126 
25128  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25129  if (mb->second.first && mb->second.first->method) {
25130  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
25131  return octave_value_list();
25132  }
25133  }
25134  }
25135 
25136 #if !SWIG_OCTAVE_PREREQ(3,2,0)
25137  mlock(me->name());
25138 #else
25139  mlock();
25140 #endif
25141 
25142  }
25143 
25145  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25146  if (mb->second.second.is_defined()) {
25147  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
25148  SWIG_Octave_LinkGlobalValue(mb->first);
25149  }
25150  }
25151 
25152  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
25153  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
25154 
25155  return octave_value_list();
25156 
25157 }
25158 
25159 
25160 static bool SWIG_init_user(octave_swig_type* module_ns)
25161 {
25162  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
25163  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
25164  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
25165  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
25166  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
25167  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
25168  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
25169  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
25170  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
25171  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
25172  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
25173  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
25174  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
25175  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
25176  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
25177  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
25178  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
25179  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
25180  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
25181  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
25182  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
25183  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
25184  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
25185  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
25186  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int((int)(25)));
25187  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int((int)(26)));
25188  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int((int)(27)));
25189  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
25190  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
25191  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
25192  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int((int)(31)));
25193  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
25194  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
25195  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int((int)(34)));
25196  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int((int)(35)));
25197  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int((int)(36)));
25198  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int((int)(37)));
25199  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int((int)(38)));
25200  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
25201  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
25202  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
25203  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
25204  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
25205  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
25206  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
25207  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
25208  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
25209  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int((int)(1)));
25210  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int((int)(2)));
25211  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int((int)(3)));
25212  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int((int)(4)));
25213  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
25214  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
25215  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
25216  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
25217  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
25218  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
25219  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
25220  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
25221  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
25222  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
25223  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
25224  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
25225  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
25226  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
25227  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
25228  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
25229  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
25230  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
25231  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
25232  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
25233  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
25234  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
25235  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
25236  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
25237  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
25238  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
25239  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
25240  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
25241  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
25242  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
25243  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
25244  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
25245  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
25246  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
25247  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
25248  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
25249  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
25250  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
25251  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
25252  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
25253  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
25254  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
25255  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
25256  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
25257  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
25258  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
25259  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int((int)(0x8)));
25260  SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int((int)(0x10)));
25261  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
25262  SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int((int)(0x40)));
25263  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
25264  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
25265  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
25266  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
25267  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
25268  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
25269  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
25270  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
25271  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
25272  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
25273  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
25274  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
25275  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
25276  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
25277  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
25278  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
25279  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
25280  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
25281  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
25282  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
25283  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
25284  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
25285  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
25286  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
25287  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
25288  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
25289  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
25290  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
25291  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
25292  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
25293  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
25294  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
25295  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
25296  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
25297  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
25298  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
25299  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
25300  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
25301  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
25302  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
25303  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
25304  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
25305  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
25306  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
25307  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
25308  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
25309  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
25310  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
25311  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
25312  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
25313  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
25314  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
25315  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
25316  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
25317  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
25318  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
25319  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
25320  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
25321  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
25322  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
25323  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
25324  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
25325  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
25326  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x001)));
25327  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x002)));
25328  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x003)));
25329  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x004)));
25330  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x008)));
25331  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x010)));
25332  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x020)));
25333  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x040)));
25334  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x080)));
25335  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
25336  return true;
25337 }
25338 
static const char * _wrap_pljoin_texinfo
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
void c_plstripc(PLINT *id, PLCHAR_VECTOR xspec, PLCHAR_VECTOR yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, PLINT_VECTOR colline, PLINT_VECTOR styline, PLCHAR_MATRIX legline, PLCHAR_VECTOR labx, PLCHAR_VECTOR laby, PLCHAR_VECTOR labtop)
Definition: plstripc.c:66
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsOK(r)
static const swig_type_info * swig_PLGraphicsIn_base[]
static swig_cast_info _swigc__p_int[]
std::string nameMapForm
static const char * _wrap_pladv_texinfo
#define plsfam
Definition: plplot.h:818
#define plw3d
Definition: plplot.h:863
void merge(octave_swig_type &rhs)
#define swigreg_binary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
octave_swig_type(const octave_swig_type &x)
static const char * _wrap_plcol0_texinfo
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plimagefr_texinfo
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swig_binary_op(name)
static const char * name
Definition: tkMain.c:135
#define plpath
Definition: plplot.h:759
static const char * _wrap_plgriddata_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
static bool SWIG_init_user(octave_swig_type *module_ns)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsmin_texinfo
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_function * fcnLabelFunc
static const char * _wrap_plsyax_texinfo
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgxax
Definition: plplot.h:743
static const char * swig_PLGraphicsIn_base_names[]
#define plsstrm
Definition: plplot.h:836
static const char *const swig_typequery_usage
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const subclass_usage
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:150
static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plschr_texinfo
#define plspage
Definition: plplot.h:832
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
#define plvpor
Definition: plplot.h:861
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plszax_texinfo
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
static const char * _wrap_plscolbga_texinfo
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
static const char * _wrap_plSetOpt_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
#define plmtex3
Definition: plplot.h:772
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plerry
Definition: plplot.h:711
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsyax
Definition: plplot.h:853
#define SWIG_OK
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pltimefmt_texinfo
#define plschr
Definition: plplot.h:792
#define plsdev
Definition: plplot.h:809
static const char * _wrap_plmapline_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plstripa_texinfo
octave_base_value * empty_clone() const
#define plgdev
Definition: plplot.h:724
PLFLT dX
Definition: plplot.h:453
virtual bool is_object() const
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
int min(int a, int b)
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcmap1_range_texinfo
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:921
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
#define SWIG_RUNTIME_VERSION
static const char * _wrap_plsori_texinfo
#define pllegend
Definition: plplot.h:756
static const char * _wrap_plstransform_texinfo
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_map() const
#define SWIG_POINTER_OWN
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
std::string swig_type_name() const
static const char * _wrap_plscmap1a_texinfo
virtual bool save_ascii(std::ostream &os)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
static const char * _wrap_plgcol0a_texinfo
#define SWIGTYPE_p_PLGraphicsIn
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
#define plshade
Definition: plplot.h:822
#define plscompression
Definition: plplot.h:808
#define plarc
Definition: plplot.h:689
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
std::string nameLabelFunc
static const char * _wrap_plstripd_texinfo
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
PLUINT PLUNICODE
Definition: plplot.h:194
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static const char * _wrap_plmeridians_texinfo
virtual Octave_map map_value() const
PL_NC_GENERIC_POINTER PLPointer
Definition: plplot.h:211
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static const char * _wrap_plmtex3_texinfo
#define plot3dc
Definition: plplot.h:774
static const char * _wrap_plpoin_texinfo
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3dcl
Definition: plplot.h:775
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllsty
Definition: plplot.h:761
#define SWIG_SystemError
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmin
Definition: plplot.h:829
#define plwind
Definition: plplot.h:868
#define plclear
Definition: plplot.h:697
#define plfill
Definition: plplot.h:713
#define plconfigtime
Definition: plplot.h:701
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
#define plsurf3dl
Definition: plplot.h:849
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpoin3_texinfo
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:628
#define plbtime
Definition: plplot.h:695
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:326
static const char * _wrap_plmesh_texinfo
#define pl_setcontlabelparam
Definition: plplot.h:687
#define SWIGTYPE_p_p_char
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolbg
Definition: plplot.h:805
swig_dycast_func dcast
static swig_type_info _swigt__p_double
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
struct swig_cast_info * cast
static const char * _wrap_plsstrm_texinfo
#define plfont
Definition: plplot.h:716
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
#define plstyl
Definition: plplot.h:847
static const char * _wrap_plgspa_texinfo
#define PL_MAXKEY
Definition: plplot.h:419
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
#define SWIG_OLDOBJ
#define plpoly3
Definition: plplot.h:780
#define SWIGINTERN
#define plimage
Definition: plplot.h:751
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
swig_type_info * type
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define plfontld
Definition: plplot.h:717
static const char * _wrap_plenv0_texinfo
#define plscolbga
Definition: plplot.h:806
#define plbin
Definition: plplot.h:691
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
#define plsdiori
Definition: plplot.h:812
static const char * _wrap_plpsty_texinfo
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:883
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:742
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plparseopts
Definition: plplot.h:776
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:673
#define plsym
Definition: plplot.h:854
#define plscmap1
Definition: plplot.h:796
std::map< std::string, member_value_pair > member_map
#define plinit
Definition: plplot.h:753
virtual std::string string_value(bool force=false) const
#define plctime
Definition: plplot.h:704
#define pltimefmt
Definition: plplot.h:857
#define plscmap1n
Definition: plplot.h:800
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void load_members(const swig_octave_class *c, member_map &out) const
static const char * _wrap_plgfont_texinfo
#define plbop
Definition: plplot.h:692
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:860
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:389
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int error
Definition: plcont.c:61
octave_swig_type * get_ptr() const
static swig_type_info _swigt__p_p_char
#define plsdiplt
Definition: plplot.h:813
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsvect
Definition: plplot.h:850
#define plscmap1a
Definition: plplot.h:797
#define plssub
Definition: plplot.h:837
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
static const char * _wrap_plcont_texinfo
member_map::const_iterator swig_member_const_iterator
static const char * _wrap_plstring_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
dim_vector dims(void) const
#define SWIG_ConvertPtr(obj, pptr, type, flags)
#define plspal1
Definition: plplot.h:834
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsetopt
Definition: plplot.h:817
#define plmeshc
Definition: plplot.h:769
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbox3_texinfo
#define plgcompression
Definition: plplot.h:723
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
#define SWIG_name
#define plszax
Definition: plplot.h:855
#define plvsta
Definition: plplot.h:862
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdidev_texinfo
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _n_dims(const octave_value &o_obj)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgpage
Definition: plplot.h:734
#define plaxes
Definition: plplot.h:690
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsori
Definition: plplot.h:831
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
#define plgdiplt
Definition: plplot.h:727
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static const char *const SWIG_name_usage
#define plscmap0a
Definition: plplot.h:794
#define SWIG_TypeError
PLINT ny
Definition: plplot.h:532
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
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)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfamadv
Definition: plplot.h:712
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plarc_texinfo
static const char * _wrap_plwind_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
#define plend
Definition: plplot.h:705
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
static const char * _wrap_plgdiori_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
static const char * _wrap_plstring3_texinfo
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsfont_texinfo
static swig_cast_info _swigc__p_double[]
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static PLINT Xlen
#define plgfont
Definition: plplot.h:732
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define plshade1
Definition: plplot.h:823
#define plend1
Definition: plplot.h:706
static const char * _wrap_plgcompression_texinfo
int PLINT
Definition: plplot.h:174
#define plenv0
Definition: plplot.h:708
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
#define plgdiori
Definition: plplot.h:726
static const char * _wrap_plgyax_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual string_vector map_keys() const
#define plshades
Definition: plplot.h:824
static const char * _wrap_plgstrm_texinfo
PLINT PLBOOL
Definition: plplot.h:197
static swig_type_info _swigt__p_char
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plstyl_texinfo
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pleop_texinfo
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:838
static const char * _wrap_plgcol0_texinfo
static const char * _wrap_plgchr_texinfo
PLFLT_NC_MATRIX yg
Definition: plplot.h:531
static const char * _wrap_plbox_texinfo
#define pljoin
Definition: plplot.h:754
#define plgzax
Definition: plplot.h:745
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_plgfci_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfam
Definition: plplot.h:729
octave_function * fcnMapForm
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_pllightsource_texinfo
static octave_value make_value_hack(const octave_base_value &x)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgver_texinfo
PLINT ny
Definition: plplot.h:520
#define plgdidev
Definition: plplot.h:725
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plgra_texinfo
#define plstar
Definition: plplot.h:839
static const char * _wrap_plsvect_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
static const char * _wrap_plsfnam_texinfo
void * cast(swig_type_info *type, int *_own, int flags)
static const char * _wrap_plgfam_texinfo
octave_function * fcnCoordTrans
const char * help_text() const
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plcont.c:508
virtual bool load_ascii(std::istream &is)
virtual bool is_object() const
swig_member_const_iterator swig_members_begin()
#define plcpstrm
Definition: plplot.h:703
static const char * _wrap_plspage_texinfo
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
#define plimagefr
Definition: plplot.h:752
#define plcalc_world
Definition: plplot.h:696
static const char * _wrap_plstripc_texinfo
void assign(const std::string &name, const swig_octave_member *m)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void assign(const std::string &name, const octave_value &ov)
#define plsfnam
Definition: plplot.h:820
static const char * _wrap_plreplot_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
#define plhist
Definition: plplot.h:746
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
octave_swig_ref(octave_swig_type *_ptr=0)
static const char *const swig_type_usage
static const char * _wrap_plsmaj_texinfo
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static PLINT Ylen
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static const char * _wrap_plscmap1_range_texinfo
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgchr
Definition: plplot.h:718
#define SWIG_exception_fail(code, msg)
struct swig_module_info * next
#define plsdidev
Definition: plplot.h:810
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SetModule(clientdata, pointer)
#define plspal0
Definition: plplot.h:833
static const char * _wrap_plvasp_texinfo
#define SWIG_ERROR
static const char * _wrap_plvsta_texinfo
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
plSetUsage
Definition: plplotc.py:8414
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscompression_texinfo
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfill3
Definition: plplot.h:714
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
octave_value operator*() const
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plimage.c:238
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
swig_converter_func converter
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plsfam_texinfo
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
octave_base_value * clone() const
static const char * _wrap_plsdidev_texinfo
#define plseed
Definition: plplot.h:815
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:519
#define SWIGTYPE_p_unsigned_int
#define plstring
Definition: plplot.h:842
plOptUsage
Definition: plplotc.py:8418
#define plstransform
Definition: plplot.h:841
#define plvect
Definition: plplot.h:859
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
#define SWIG_as_voidptr(a)
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plgradient_texinfo
#define SWIG_DelNewMask(r)
#define SWIG_ArgError(r)
void load_members(member_map &out) const
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plend1_texinfo
virtual bool is_map() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static const char * _wrap_plspal0_texinfo
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plscmap1_texinfo
#define plscmap1la
Definition: plplot.h:799
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfnam
Definition: plplot.h:731
static const char * _wrap_plssub_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plpat_texinfo
#define plcont
Definition: plplot.h:702
#define plsxax
Definition: plplot.h:852
#define plstart
Definition: plplot.h:840
plClearOpts
Definition: plplotc.py:8406
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plshades_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
static const char * _wrap_plgvpd_texinfo
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pleop
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:768
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plhlsrgb
Definition: plplot.h:750
swig_type_info ** types
std::string nameCoordTrans
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgvpw_texinfo
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
#define SWIG_IsNewObj(r)
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmaj
Definition: plplot.h:826
PLINT nx
Definition: plplot.h:532
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plvpor_texinfo
bool dispatch_unary_op(const std::string &symbol, octave_value &ret)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
static const char * _wrap_plflush_texinfo
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plfill3_texinfo
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
#define SWIGTYPE_p_int
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol1
Definition: plplot.h:699
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define pllab
Definition: plplot.h:755
#define pllightsource
Definition: plplot.h:757
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plprec_texinfo
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbox
Definition: plplot.h:693
pl_setcontlabelformat
Definition: tclgen_s.h:1
static const char * _wrap_plstar_texinfo
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
static const char * _wrap_plseed_texinfo
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_string() const
#define pltext
Definition: plplot.h:856
virtual bool save_ascii(std::ostream &os)
virtual bool save_ascii(std::ostream &os)
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plptex_texinfo
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type & operator=(const octave_swig_type &rhs)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plwidth
Definition: plplot.h:867
static swig_type_info _swigt__p_int
#define plgver
Definition: plplot.h:740
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static const char * _wrap_plscmap0n_texinfo
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscolbg_texinfo
#define plscol0a
Definition: plplot.h:804
#define plptex3
Definition: plplot.h:784
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
#define plsdiplz
Definition: plplot.h:814
unsigned int keysym
Definition: plplot.h:448
static const char * _wrap_plsdev_texinfo
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define plspause
Definition: plplot.h:835
const swig_type_info ** base
static swig_type_info * swig_types[10]
static const char * _wrap_plbtime_texinfo
void c_plshades(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:216
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline3
Definition: plplot.h:760
#define plstripd
Definition: plplot.h:846
#define plgfci
Definition: plplot.h:730
#define plgspa
Definition: plplot.h:738
#define plgcolbg
Definition: plplot.h:721
static const char * _wrap_plot3dcl_texinfo
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
#define plstripc
Definition: plplot.h:845
DEFUN_DLD(subclass, args, nargout, subclass_usage)
#define plstripa
Definition: plplot.h:844
static const char * _wrap_plgzax_texinfo
#define SWIG_global_name
static const char * _wrap_plenv_texinfo
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstring3
Definition: plplot.h:843
#define SWIG_NEWOBJ
static const char * _wrap_plscmap1l_texinfo
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvpas
Definition: plplot.h:860
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
#define plsfont
Definition: plplot.h:821
void my_plshadesx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, PLFLT *tr)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:695
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
Definition: pllegend.c:1525
static const char * _wrap_plsurf3dl_texinfo
#define f2c(f, ff, nx, ny)
#define SWIG_IsTmpObj(r)
static const char * _wrap_plfontld_texinfo
#define plpsty
Definition: plplot.h:782
static const char * _wrap_plerry_texinfo
static const char * _wrap_plline3_texinfo
static const char * _wrap_plscmap1n_texinfo
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1209
#define plgvpd
Definition: plplot.h:741
static swig_octave_class _wrap_class_PLGraphicsIn
#define plpoin
Definition: plplot.h:778
#define plgriddata
Definition: plplot.h:737
#define plgvpw
Definition: plplot.h:742
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT wX
Definition: plplot.h:454
#define SWIGRUNTIMEINLINE
PLINT subwindow
Definition: plplot.h:450
static swig_cast_info _swigc__p_unsigned_int[]
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IndexError
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_plgcolbg_texinfo
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plrandd_texinfo
int max(int a, int b)
static const char * _wrap_plspal1_texinfo
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
static const char * _wrap_plmtex_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plfont_texinfo
static const char *const swig_this_usage
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
#define SWIG_AttributeError
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
static const char * _wrap_plline_texinfo
static const char * _wrap_plbop_texinfo
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_name_d
void my_plcont2(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plcolorbar_texinfo
#define plmkstrm
Definition: plplot.h:770
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
float PLFLT
Definition: plplot.h:157
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
#define plscol0
Definition: plplot.h:803
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_pltext_texinfo
#define plxormod
Definition: plplot.h:869
static const char * _wrap_plxormod_texinfo
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plerrx_texinfo
#define plflush
Definition: plplot.h:715
#define plerrx
Definition: plplot.h:710
#define plgcol0a
Definition: plplot.h:720
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IOError
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define plgcolbga
Definition: plplot.h:722
static const char * _wrap_plsdiplt_texinfo
static const char * _wrap_plfill_texinfo
static const char * _wrap_plpoly3_texinfo
static const char * _wrap_plscolor_texinfo
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscol0a_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plsym_texinfo
static const char * _wrap_plbin_texinfo
#define SWIG_AddCast(r)
PLINT(* defined_func)(PLFLT, PLFLT)
#define plgyax
Definition: plplot.h:744
#define plsesc
Definition: plplot.h:816
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plenv
Definition: plplot.h:707
static PLINT Alen
#define swigreg_unary_op(name)
swig_member_const_iterator swig_members_end()
static const char * _wrap_plsesc_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
struct swig_cast_info * next
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plvect_texinfo
static const char * _wrap_plw3d_texinfo
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
static const char * _wrap_plglevel_texinfo
#define SWIG_op_prefix
const swig_octave_member * members
#define plgcmap1_range
Definition: plplot.h:802
#define plcol0
Definition: plplot.h:698
#define SWIG_RuntimeError
SWIGRUNTIME void SWIG_InstallOps(int tid)
#define plbox3
Definition: plplot.h:694
virtual std::string string_value(bool force=false) const
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static int _arraylen(const octave_value &o_obj)
#define plcolorbar
Definition: plplot.h:700
static swig_cast_info * swig_cast_initial[]
static const char * _wrap_plstart_texinfo
unsigned int state
Definition: plplot.h:447
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
#define SWIG_fail
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:733
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsurf3d_texinfo
static const char * _wrap_pllab_texinfo
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:519
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref,"swig_ref","swig_ref")
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static const char * _wrap_plgpage_texinfo
#define SWIG_ValueError
#define plpoin3
Definition: plplot.h:779
struct swig_cast_info swig_cast_info
static const struct swig_octave_member swig_globals[]
static const char * _wrap_plsdiplz_texinfo
#define plscmap0n
Definition: plplot.h:795
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
std::pair< const swig_octave_member *, octave_value > member_value_pair
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolor
Definition: plplot.h:807
#define plsvpa
Definition: plplot.h:851
octave_value_ref(const octave_value_list &_ovl, int _j)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpat
Definition: plplot.h:777
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1_range
Definition: plplot.h:801
#define SWIG_POINTER_DISOWN
static const char * _wrap_plcalc_world_texinfo
struct swig_cast_info * prev
static const char * _wrap_plcol1_texinfo
static const char * _wrap_plot3d_texinfo
#define plgcol0
Definition: plplot.h:719
static const char * _wrap_plslabelfunc_texinfo
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plvect.c:261
static const char * _wrap_plshade_texinfo
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
#define plreplot
Definition: plplot.h:786
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
swig_cast_info ** cast_initial
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plmeshc_texinfo
static const char * _wrap_plmkstrm_texinfo
unsigned int button
Definition: plplot.h:449
static swig_type_info * swig_type_initial[]
#define SWIG_DEFUN(cname, wname, doc)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plpath_texinfo
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbga_texinfo
#define swig_unary_op(name)
#define plscmap1l
Definition: plplot.h:798
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:599
static const char * _wrap_plgfnam_texinfo
#define plprec
Definition: plplot.h:781
#define SWIG_DivisionByZero
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plcpstrm_texinfo
virtual Octave_map map_value() const
void c_plshade(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:352
#define plptex
Definition: plplot.h:783
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmap_texinfo
const swig_type_info * construct_type
static const char * _wrap_pllsty_texinfo
virtual bool is_string() const
#define plline
Definition: plplot.h:758
PLFLT dY
Definition: plplot.h:453
#define SWIG_MemoryError
PLFLT_NC_MATRIX xg
Definition: plplot.h:531
static const char * _wrap_pllegend_texinfo
static const char * _wrap_plptex3_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
void my_plshade1(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define plgradient
Definition: plplot.h:736
static const char * _wrap_plclear_texinfo
static const char * _wrap_plaxes_texinfo
const octave_value_list & ovl
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsdiori_texinfo
swig_type_info ** type_initial
static const char * _wrap_plend_texinfo
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plscol0_texinfo
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
#define pladv
Definition: plplot.h:688
#define plvasp
Definition: plplot.h:858
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrandd
Definition: plplot.h:785
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmaptex_texinfo
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0
Definition: plplot.h:793
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssym_texinfo
static int _dim(const octave_value &o_obj, int dim_idx)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:650
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgstrm
Definition: plplot.h:739
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info swig_type_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
#define plsfci
Definition: plplot.h:819
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plmapfill_texinfo
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
PLFLT wY
Definition: plplot.h:454
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plfamadv_texinfo
char string[PL_MAXKEY]
Definition: plplot.h:451
plResetOpts
Definition: plplotc.py:8410
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
#define plmtex
Definition: plplot.h:771
static const char * _wrap_plgxax_texinfo
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrgbhls
Definition: plplot.h:791
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsurf3d
Definition: plplot.h:848
static const char * _wrap_plspause_texinfo
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgra
Definition: plplot.h:735
static const char * _wrap_plmapstring_texinfo
static const char * _wrap_plctime_texinfo
#define plsdimap
Definition: plplot.h:811
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsvpa_texinfo
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
dim_vector dims(void) const
static swig_cast_info _swigc__p_PLGraphicsIn[]
static const char * _wrap_plvpas_texinfo
#define plot3d
Definition: plplot.h:773
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_plconfigtime_texinfo
#define plslabelfunc
Definition: plplot.h:825
PLINT nx
Definition: plplot.h:520
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plot3dc_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
static const char * _wrap_plscmap0_texinfo
#define SWIG_NewPointerObj(ptr, type, flags)
std::vector< type_ptr_pair > types
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plhist_texinfo
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)