PLplot  5.10.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plplot_octaveOCTAVE_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.7
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGOCTAVE
12 #define SWIG_name_d "plplot_octave"
13 #define SWIG_name plplot_octave
14 
15 #define SWIG_global_name "cvar"
16 #define SWIG_op_prefix "op_"
17 
18 
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22  struct SwigMovePointer {
23  T *ptr;
24  SwigMovePointer(T *p) : ptr(p) { }
25  ~SwigMovePointer() { delete ptr; }
26  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27  } pointer;
28  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31  SwigValueWrapper() : pointer(0) { }
32  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33  operator T&() const { return *pointer.ptr; }
34  T *operator&() { return pointer.ptr; }
35 };
36 
37 template <typename T> T SwigValueInit() {
38  return T();
39 }
40 #endif
41 
42 /* -----------------------------------------------------------------------------
43  * This section contains generic SWIG labels for method/variable
44  * declarations/attributes, and other compiler dependent labels.
45  * ----------------------------------------------------------------------------- */
46 
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59 
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68 
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83 
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89 
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97 
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102 
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107 
108 /* exporting methods */
109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 # ifndef GCC_HASCLASSVISIBILITY
111 # define GCC_HASCLASSVISIBILITY
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 
151 
152 #include <iostream>
153 #include <octave/oct.h>
154 #include <octave/Cell.h>
155 #include <octave/dynamic-ld.h>
156 #include <octave/oct-env.h>
157 #include <octave/oct-map.h>
158 #include <octave/ov-fcn-handle.h>
159 #include <octave/parse.h>
160 #include <octave/toplev.h>
161 #include <octave/unwind-prot.h>
162 
163 /* -----------------------------------------------------------------------------
164  * swigrun.swg
165  *
166  * This file contains generic C API SWIG runtime support for pointer
167  * type checking.
168  * ----------------------------------------------------------------------------- */
169 
170 /* This should only be incremented when either the layout of swig_type_info changes,
171  or for whatever reason, the runtime changes incompatibly */
172 #define SWIG_RUNTIME_VERSION "4"
173 
174 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
175 #ifdef SWIG_TYPE_TABLE
176 # define SWIG_QUOTE_STRING(x) #x
177 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
178 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
179 #else
180 # define SWIG_TYPE_TABLE_NAME
181 #endif
182 
183 /*
184  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
185  creating a static or dynamic library from the SWIG runtime code.
186  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
187 
188  But only do this if strictly necessary, ie, if you have problems
189  with your compiler or suchlike.
190 */
191 
192 #ifndef SWIGRUNTIME
193 # define SWIGRUNTIME SWIGINTERN
194 #endif
195 
196 #ifndef SWIGRUNTIMEINLINE
197 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
198 #endif
199 
200 /* Generic buffer size */
201 #ifndef SWIG_BUFFER_SIZE
202 # define SWIG_BUFFER_SIZE 1024
203 #endif
204 
205 /* Flags for pointer conversions */
206 #define SWIG_POINTER_DISOWN 0x1
207 #define SWIG_CAST_NEW_MEMORY 0x2
208 
209 /* Flags for new pointer objects */
210 #define SWIG_POINTER_OWN 0x1
211 
212 
213 /*
214  Flags/methods for returning states.
215 
216  The SWIG conversion methods, as ConvertPtr, return an integer
217  that tells if the conversion was successful or not. And if not,
218  an error code can be returned (see swigerrors.swg for the codes).
219 
220  Use the following macros/flags to set or process the returning
221  states.
222 
223  In old versions of SWIG, code such as the following was usually written:
224 
225  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
226  // success code
227  } else {
228  //fail code
229  }
230 
231  Now you can be more explicit:
232 
233  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
234  if (SWIG_IsOK(res)) {
235  // success code
236  } else {
237  // fail code
238  }
239 
240  which is the same really, but now you can also do
241 
242  Type *ptr;
243  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
244  if (SWIG_IsOK(res)) {
245  // success code
246  if (SWIG_IsNewObj(res) {
247  ...
248  delete *ptr;
249  } else {
250  ...
251  }
252  } else {
253  // fail code
254  }
255 
256  I.e., now SWIG_ConvertPtr can return new objects and you can
257  identify the case and take care of the deallocation. Of course that
258  also requires SWIG_ConvertPtr to return new result values, such as
259 
260  int SWIG_ConvertPtr(obj, ptr,...) {
261  if (<obj is ok>) {
262  if (<need new object>) {
263  *ptr = <ptr to new allocated object>;
264  return SWIG_NEWOBJ;
265  } else {
266  *ptr = <ptr to old object>;
267  return SWIG_OLDOBJ;
268  }
269  } else {
270  return SWIG_BADOBJ;
271  }
272  }
273 
274  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
275  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
276  SWIG errors code.
277 
278  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
279  allows to return the 'cast rank', for example, if you have this
280 
281  int food(double)
282  int fooi(int);
283 
284  and you call
285 
286  food(1) // cast rank '1' (1 -> 1.0)
287  fooi(1) // cast rank '0'
288 
289  just use the SWIG_AddCast()/SWIG_CheckState()
290 */
291 
292 #define SWIG_OK (0)
293 #define SWIG_ERROR (-1)
294 #define SWIG_IsOK(r) (r >= 0)
295 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
296 
297 /* The CastRankLimit says how many bits are used for the cast rank */
298 #define SWIG_CASTRANKLIMIT (1 << 8)
299 /* The NewMask denotes the object was created (using new/malloc) */
300 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
301 /* The TmpMask is for in/out typemaps that use temporal objects */
302 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
303 /* Simple returning values */
304 #define SWIG_BADOBJ (SWIG_ERROR)
305 #define SWIG_OLDOBJ (SWIG_OK)
306 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
307 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
308 /* Check, add and del mask methods */
309 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
310 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
311 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
312 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
313 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
314 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
315 
316 /* Cast-Rank Mode */
317 #if defined(SWIG_CASTRANK_MODE)
318 # ifndef SWIG_TypeRank
319 # define SWIG_TypeRank unsigned long
320 # endif
321 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
322 # define SWIG_MAXCASTRANK (2)
323 # endif
324 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
325 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
326 SWIGINTERNINLINE int SWIG_AddCast(int r) {
327  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
328 }
329 SWIGINTERNINLINE int SWIG_CheckState(int r) {
330  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
331 }
332 #else /* no cast-rank mode */
333 # define SWIG_AddCast
334 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
335 #endif
336 
337 
338 #include <string.h>
339 
340 #ifdef __cplusplus
341 extern "C" {
342 #endif
343 
344 typedef void *(*swig_converter_func)(void *, int *);
345 typedef struct swig_type_info *(*swig_dycast_func)(void **);
346 
347 /* Structure to store information on one type */
348 typedef struct swig_type_info {
349  const char *name; /* mangled name of this type */
350  const char *str; /* human readable name of this type */
351  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
352  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
353  void *clientdata; /* language specific type data */
354  int owndata; /* flag if the structure owns the clientdata */
356 
357 /* Structure to store a type and conversion function used for casting */
358 typedef struct swig_cast_info {
359  swig_type_info *type; /* pointer to type that is equivalent to this type */
360  swig_converter_func converter; /* function to cast the void pointers */
361  struct swig_cast_info *next; /* pointer to next cast in linked list */
362  struct swig_cast_info *prev; /* pointer to the previous cast */
364 
365 /* Structure used to store module information
366  * Each module generates one structure like this, and the runtime collects
367  * all of these structures and stores them in a circularly linked list.*/
368 typedef struct swig_module_info {
369  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
370  size_t size; /* Number of types in this module */
371  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
372  swig_type_info **type_initial; /* Array of initially generated type structures */
373  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
374  void *clientdata; /* Language specific module data */
376 
377 /*
378  Compare two type names skipping the space characters, therefore
379  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
380 
381  Return 0 when the two name types are equivalent, as in
382  strncmp, but skipping ' '.
383 */
384 SWIGRUNTIME int
385 SWIG_TypeNameComp(const char *f1, const char *l1,
386  const char *f2, const char *l2) {
387  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
388  while ((*f1 == ' ') && (f1 != l1)) ++f1;
389  while ((*f2 == ' ') && (f2 != l2)) ++f2;
390  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
391  }
392  return (int)((l1 - f1) - (l2 - f2));
393 }
394 
395 /*
396  Check type equivalence in a name list like <name1>|<name2>|...
397  Return 0 if not equal, 1 if equal
398 */
399 SWIGRUNTIME int
400 SWIG_TypeEquiv(const char *nb, const char *tb) {
401  int equiv = 0;
402  const char* te = tb + strlen(tb);
403  const char* ne = nb;
404  while (!equiv && *ne) {
405  for (nb = ne; *ne; ++ne) {
406  if (*ne == '|') break;
407  }
408  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
409  if (*ne) ++ne;
410  }
411  return equiv;
412 }
413 
414 /*
415  Check type equivalence in a name list like <name1>|<name2>|...
416  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
417 */
418 SWIGRUNTIME int
419 SWIG_TypeCompare(const char *nb, const char *tb) {
420  int equiv = 0;
421  const char* te = tb + strlen(tb);
422  const char* ne = nb;
423  while (!equiv && *ne) {
424  for (nb = ne; *ne; ++ne) {
425  if (*ne == '|') break;
426  }
427  equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
428  if (*ne) ++ne;
429  }
430  return equiv;
431 }
432 
433 
434 /*
435  Check the typename
436 */
438 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
439  if (ty) {
440  swig_cast_info *iter = ty->cast;
441  while (iter) {
442  if (strcmp(iter->type->name, c) == 0) {
443  if (iter == ty->cast)
444  return iter;
445  /* Move iter to the top of the linked list */
446  iter->prev->next = iter->next;
447  if (iter->next)
448  iter->next->prev = iter->prev;
449  iter->next = ty->cast;
450  iter->prev = 0;
451  if (ty->cast) ty->cast->prev = iter;
452  ty->cast = iter;
453  return iter;
454  }
455  iter = iter->next;
456  }
457  }
458  return 0;
459 }
460 
461 /*
462  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
463 */
466  if (ty) {
467  swig_cast_info *iter = ty->cast;
468  while (iter) {
469  if (iter->type == from) {
470  if (iter == ty->cast)
471  return iter;
472  /* Move iter to the top of the linked list */
473  iter->prev->next = iter->next;
474  if (iter->next)
475  iter->next->prev = iter->prev;
476  iter->next = ty->cast;
477  iter->prev = 0;
478  if (ty->cast) ty->cast->prev = iter;
479  ty->cast = iter;
480  return iter;
481  }
482  iter = iter->next;
483  }
484  }
485  return 0;
486 }
487 
488 /*
489  Cast a pointer up an inheritance hierarchy
490 */
491 SWIGRUNTIMEINLINE void *
492 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
493  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
494 }
495 
496 /*
497  Dynamic pointer casting. Down an inheritance hierarchy
498 */
501  swig_type_info *lastty = ty;
502  if (!ty || !ty->dcast) return ty;
503  while (ty && (ty->dcast)) {
504  ty = (*ty->dcast)(ptr);
505  if (ty) lastty = ty;
506  }
507  return lastty;
508 }
509 
510 /*
511  Return the name associated with this type
512 */
513 SWIGRUNTIMEINLINE const char *
515  return ty->name;
516 }
517 
518 /*
519  Return the pretty name associated with this type,
520  that is an unmangled type name in a form presentable to the user.
521 */
522 SWIGRUNTIME const char *
524  /* The "str" field contains the equivalent pretty names of the
525  type, separated by vertical-bar characters. We choose
526  to print the last name, as it is often (?) the most
527  specific. */
528  if (!type) return NULL;
529  if (type->str != NULL) {
530  const char *last_name = type->str;
531  const char *s;
532  for (s = type->str; *s; s++)
533  if (*s == '|') last_name = s+1;
534  return last_name;
535  }
536  else
537  return type->name;
538 }
539 
540 /*
541  Set the clientdata field for a type
542 */
543 SWIGRUNTIME void
545  swig_cast_info *cast = ti->cast;
546  /* if (ti->clientdata == clientdata) return; */
547  ti->clientdata = clientdata;
548 
549  while (cast) {
550  if (!cast->converter) {
551  swig_type_info *tc = cast->type;
552  if (!tc->clientdata) {
553  SWIG_TypeClientData(tc, clientdata);
554  }
555  }
556  cast = cast->next;
557  }
558 }
559 SWIGRUNTIME void
561  SWIG_TypeClientData(ti, clientdata);
562  ti->owndata = 1;
563 }
564 
565 /*
566  Search for a swig_type_info structure only by mangled name
567  Search is a O(log #types)
568 
569  We start searching at module start, and finish searching when start == end.
570  Note: if start == end at the beginning of the function, we go all the way around
571  the circular list.
572 */
575  swig_module_info *end,
576  const char *name) {
577  swig_module_info *iter = start;
578  do {
579  if (iter->size) {
580  register size_t l = 0;
581  register size_t r = iter->size - 1;
582  do {
583  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
584  register size_t i = (l + r) >> 1;
585  const char *iname = iter->types[i]->name;
586  if (iname) {
587  register int compare = strcmp(name, iname);
588  if (compare == 0) {
589  return iter->types[i];
590  } else if (compare < 0) {
591  if (i) {
592  r = i - 1;
593  } else {
594  break;
595  }
596  } else if (compare > 0) {
597  l = i + 1;
598  }
599  } else {
600  break; /* should never happen */
601  }
602  } while (l <= r);
603  }
604  iter = iter->next;
605  } while (iter != end);
606  return 0;
607 }
608 
609 /*
610  Search for a swig_type_info structure for either a mangled name or a human readable name.
611  It first searches the mangled names of the types, which is a O(log #types)
612  If a type is not found it then searches the human readable names, which is O(#types).
613 
614  We start searching at module start, and finish searching when start == end.
615  Note: if start == end at the beginning of the function, we go all the way around
616  the circular list.
617 */
620  swig_module_info *end,
621  const char *name) {
622  /* STEP 1: Search the name field using binary search */
623  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
624  if (ret) {
625  return ret;
626  } else {
627  /* STEP 2: If the type hasn't been found, do a complete search
628  of the str field (the human readable name) */
629  swig_module_info *iter = start;
630  do {
631  register size_t i = 0;
632  for (; i < iter->size; ++i) {
633  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
634  return iter->types[i];
635  }
636  iter = iter->next;
637  } while (iter != end);
638  }
639 
640  /* neither found a match */
641  return 0;
642 }
643 
644 /*
645  Pack binary data into a string
646 */
647 SWIGRUNTIME char *
648 SWIG_PackData(char *c, void *ptr, size_t sz) {
649  static const char hex[17] = "0123456789abcdef";
650  register const unsigned char *u = (unsigned char *) ptr;
651  register const unsigned char *eu = u + sz;
652  for (; u != eu; ++u) {
653  register unsigned char uu = *u;
654  *(c++) = hex[(uu & 0xf0) >> 4];
655  *(c++) = hex[uu & 0xf];
656  }
657  return c;
658 }
659 
660 /*
661  Unpack binary data from a string
662 */
663 SWIGRUNTIME const char *
664 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
665  register unsigned char *u = (unsigned char *) ptr;
666  register const unsigned char *eu = u + sz;
667  for (; u != eu; ++u) {
668  register char d = *(c++);
669  register unsigned char uu;
670  if ((d >= '0') && (d <= '9'))
671  uu = ((d - '0') << 4);
672  else if ((d >= 'a') && (d <= 'f'))
673  uu = ((d - ('a'-10)) << 4);
674  else
675  return (char *) 0;
676  d = *(c++);
677  if ((d >= '0') && (d <= '9'))
678  uu |= (d - '0');
679  else if ((d >= 'a') && (d <= 'f'))
680  uu |= (d - ('a'-10));
681  else
682  return (char *) 0;
683  *u = uu;
684  }
685  return c;
686 }
687 
688 /*
689  Pack 'void *' into a string buffer.
690 */
691 SWIGRUNTIME char *
692 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
693  char *r = buff;
694  if ((2*sizeof(void *) + 2) > bsz) return 0;
695  *(r++) = '_';
696  r = SWIG_PackData(r,&ptr,sizeof(void *));
697  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
698  strcpy(r,name);
699  return buff;
700 }
701 
702 SWIGRUNTIME const char *
703 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
704  if (*c != '_') {
705  if (strcmp(c,"NULL") == 0) {
706  *ptr = (void *) 0;
707  return name;
708  } else {
709  return 0;
710  }
711  }
712  return SWIG_UnpackData(++c,ptr,sizeof(void *));
713 }
714 
715 SWIGRUNTIME char *
716 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
717  char *r = buff;
718  size_t lname = (name ? strlen(name) : 0);
719  if ((2*sz + 2 + lname) > bsz) return 0;
720  *(r++) = '_';
721  r = SWIG_PackData(r,ptr,sz);
722  if (lname) {
723  strncpy(r,name,lname+1);
724  } else {
725  *r = 0;
726  }
727  return buff;
728 }
729 
730 SWIGRUNTIME const char *
731 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
732  if (*c != '_') {
733  if (strcmp(c,"NULL") == 0) {
734  memset(ptr,0,sz);
735  return name;
736  } else {
737  return 0;
738  }
739  }
740  return SWIG_UnpackData(++c,ptr,sz);
741 }
742 
743 #ifdef __cplusplus
744 }
745 #endif
746 
747 /* Errors in SWIG */
748 #define SWIG_UnknownError -1
749 #define SWIG_IOError -2
750 #define SWIG_RuntimeError -3
751 #define SWIG_IndexError -4
752 #define SWIG_TypeError -5
753 #define SWIG_DivisionByZero -6
754 #define SWIG_OverflowError -7
755 #define SWIG_SyntaxError -8
756 #define SWIG_ValueError -9
757 #define SWIG_SystemError -10
758 #define SWIG_AttributeError -11
759 #define SWIG_MemoryError -12
760 #define SWIG_NullReferenceError -13
761 
762 
763 
764 
765 #include <octave/version.h>
766 #ifndef OCTAVE_API_VERSION_NUMBER
767 
768  // Hack to distinguish between Octave 3.2 and earlier versions before OCTAVE_API_VERSION_NUMBER existed
769  #define ComplexLU __ignore
770  #include <octave/CmplxLU.h>
771  #undef ComplexLU
772  #ifdef octave_Complex_LU_h
773  # define OCTAVE_API_VERSION_NUMBER 36
774  #else
775  # define OCTAVE_API_VERSION_NUMBER 37
776  #endif
777 
778 #endif
779 
780 #if OCTAVE_API_VERSION_NUMBER < 37
781 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
782 #else
783 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
784 #endif
785 
786 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
787  if (num_args > max_args && !varargs)
788  error("function %s takes at most %i arguments", func_name, max_args);
789  else if (num_args < min_args)
790  error("function %s requires at least %i arguments", func_name, min_args);
791  else
792  return true;
793  return false;
794 }
795 
796 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
797  ovl->append(ov);
798  return ovl;
799 }
800 
801 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
802  switch (code) {
803  case SWIG_MemoryError:
804  return "SWIG_MemoryError";
805  case SWIG_IOError:
806  return "SWIG_IOError";
807  case SWIG_RuntimeError:
808  return "SWIG_RuntimeError";
809  case SWIG_IndexError:
810  return "SWIG_IndexError";
811  case SWIG_TypeError:
812  return "SWIG_TypeError";
813  case SWIG_DivisionByZero:
814  return "SWIG_DivisionByZero";
815  case SWIG_OverflowError:
816  return "SWIG_OverflowError";
817  case SWIG_SyntaxError:
818  return "SWIG_SyntaxError";
819  case SWIG_ValueError:
820  return "SWIG_ValueError";
821  case SWIG_SystemError:
822  return "SWIG_SystemError";
823  case SWIG_AttributeError:
824  return "SWIG_AttributeError";
825  }
826  return "SWIG unknown error";
827 }
828 
829 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
830  octave_value type(SWIG_ErrorType(code));
831  std::string r = msg;
832  r += " (" + type.string_value() + ")";
833  error(r.c_str());
834  return octave_value(r);
835 }
836 
837 #define SWIG_fail goto fail
838 
839 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
840 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
841 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
842 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
843 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
844 #define swig_owntype int
845 
846 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
847 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
848 
849 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
850 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
851 
852 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
853 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
854 
855 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
856 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
857 #define SWIG_MODULE_CLIENTDATA_TYPE void*
858 
859 #define Octave_Error_Occurred() 0
860 #define SWIG_Octave_AddErrorMsg(msg) {;}
861 
864 
865 // For backward compatibility only
866 #define SWIG_POINTER_EXCEPTION 0
867 #define SWIG_arg_fail(arg) 0
868 
869 // Runtime API implementation
870 
871 #include <map>
872 #include <vector>
873 #include <string>
874 
875 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
876 class octave_swig_type;
877 
878 namespace Swig {
879 
880 #ifdef SWIG_DIRECTORS
881 
882  class Director;
883 
884  typedef std::map < void *, Director * > rtdir_map;
885  SWIGINTERN rtdir_map* get_rtdir_map();
886  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
887  SWIGINTERNINLINE void erase_rtdir(void *vptr);
888  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
889 
890  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
891  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
892  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
893 
894 #endif
895 
896  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
898  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
899 }
900 
901 #ifdef SWIG_DIRECTORS
902 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
903 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
904 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
905 #endif
906 
908  const char *name;
912  int flags; // 1 static, 2 global
913  const char *doc;
914  bool is_static() const {
915  return flags &1;
916  } bool is_global() const {
917  return flags &2;
918  }
919  };
920 
922  const char *name;
924  int director;
926  const char *constructor_doc;
929  const char **base_names;
931  };
932 
933  // octave_swig_type plays the role of both the shadow class and the class
934  // representation within Octave, since there is no support for classes.
935  //
936  // These should really be decoupled, with the class support added to Octave
937  // and the shadow class given by an m-file script. That would dramatically
938  // reduce the runtime complexity, and be more in line w/ other modules.
939 
940  class octave_swig_type:public octave_base_value {
941  struct cpp_ptr {
942  void *ptr;
943  bool destroyed;
944  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
945  }};
946  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
947 
949 
950  const swig_type_info *construct_type; // type of special type object
951  std::vector < type_ptr_pair > types; // our c++ base classes
952  int own; // whether we call c++ destructors when we die
953 
954  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
955  typedef std::map < std::string, member_value_pair > member_map;
958 
959  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
960  if (!type->clientdata)
961  return 0;
963  const swig_octave_member *m;
964  for (m = c->members; m->name; ++m)
965  if (m->name == name)
966  return m;
967  for (int j = 0; c->base_names[j]; ++j) {
968  if (!c->base[j]) {
969  if (!module)
970  module = SWIG_GetModule(0);
971  assert(module);
973  }
974  if (!c->base[j])
975  return 0;
976  if ((m = find_member(c->base[j], name)))
977  return m;
978  }
979  return 0;
980  }
981 
982  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
983  member_map::iterator it = members.find(name);
984  if (it != members.end())
985  return &it->second;
986  const swig_octave_member *m;
987  for (unsigned int j = 0; j < types.size(); ++j)
988  if ((m = find_member(types[j].first, name)))
989  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
990  if (!insert_if_not_found)
991  return 0;
992  return &members[name];
993  }
994 
995  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
996  if (!base) {
997  for (unsigned int j = 0; j < types.size(); ++j) {
998  assert(types[j].first->clientdata);
999  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1000  if (cj->name == name)
1001  return types[j].first;
1002  }
1003  return 0;
1004  }
1005  assert(base->clientdata);
1007  for (int j = 0; c->base_names[j]; ++j) {
1008  if (!c->base[j]) {
1009  if (!module)
1010  module = SWIG_GetModule(0);
1011  assert(module);
1013  }
1014  if (!c->base[j])
1015  return 0;
1016  assert(c->base[j]->clientdata);
1018  if (cj->name == name)
1019  return c->base[j];
1020  }
1021  return 0;
1022  }
1023 
1024  void load_members(const swig_octave_class* c,member_map& out) const {
1025  for (const swig_octave_member *m = c->members; m->name; ++m) {
1026  if (out.find(m->name) == out.end())
1027  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1028  }
1029  for (int j = 0; c->base_names[j]; ++j) {
1030  if (!c->base[j]) {
1031  if (!module)
1032  module = SWIG_GetModule(0);
1033  assert(module);
1035  }
1036  if (!c->base[j])
1037  continue;
1038  assert(c->base[j]->clientdata);
1039  const swig_octave_class *cj =
1040  (const swig_octave_class *) c->base[j]->clientdata;
1041  load_members(cj,out);
1042  }
1043  }
1044 
1045  void load_members(member_map& out) const {
1046  out=members;
1047  for (unsigned int j = 0; j < types.size(); ++j)
1048  if (types[j].first->clientdata)
1049  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1050  }
1051 
1052  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1053  if (m->second.is_defined())
1054  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1055  else if (m->first && m->first->method)
1056  return m->first->method(args, nargout);
1057  error("member not defined or not invocable");
1058  return octave_value_list();
1059  }
1060 
1061  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
1062  member_value_pair *m = find_member(symbol, false);
1063  if (!m || m->first->is_static() || m->first->is_global())
1064  return false;
1065  octave_value_list args;
1066  args.append(as_value());
1067  octave_value_list argout(member_invoke(m, args, 1));
1068  if (argout.length() < 1)
1069  return false;
1070  ret = argout(0);
1071  return true;
1072  }
1073 
1074  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
1075  member_value_pair *m = find_member(symbol, false);
1076  if (!m || m->first->is_static() || m->first->is_global())
1077  return false;
1078  octave_value_list args;
1079  args.append(as_value());
1080  args.append(make_value_hack(rhs));
1081  octave_value_list argout(member_invoke(m, args, 1));
1082  if (argout.length() < 1)
1083  return false;
1084  ret = argout(0);
1085  return true;
1086  }
1087 
1088  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
1089  member_value_pair *m = find_member(symbol, false);
1090  if (!m || m->first->is_static() || m->first->is_global())
1091  return false;
1092  octave_value_list args;
1093  args.append(as_value());
1094  args.append(rhs);
1095  octave_value_list argout(member_invoke(m, args, 1));
1096  if (argout.length() >= 1)
1097  ret = argout(0);
1098  return true;
1099  }
1100 
1101  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1102  if (m->second.is_defined())
1103  return m->second;
1104  else if (m->first) {
1105  if (m->first->get_method)
1106  return m->first->get_method(args, 1);
1107  else if (m->first->method)
1108  return octave_value(new octave_builtin(m->first->method));
1109  }
1110  error("undefined member");
1111  return octave_value_list();
1112  }
1113 
1114  static octave_value make_value_hack(const octave_base_value &x) {
1115  ((octave_swig_type &) x).count++;
1116  return octave_value((octave_base_value *) &x);
1117  }
1118 
1121  public:
1122 
1123  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1124  bool _always_static = false)
1125  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1126  always_static(_always_static) {
1127  if (_type || _ptr)
1128  types.push_back(std::make_pair(_type, _ptr));
1129 #ifdef SWIG_DIRECTORS
1130  if (_ptr) {
1131  Swig::Director *d = Swig::get_rtdir(_ptr);
1132  if (d)
1133  Swig::swig_director_set_self(d, this);
1134  }
1135 #endif
1136  }
1137 
1139  if (own) {
1140  ++count;
1141  for (unsigned int j = 0; j < types.size(); ++j) {
1142  if (!types[j].first || !types[j].first->clientdata)
1143  continue;
1144  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1145  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1146  c->destructor(as_value(), 0);
1147  }
1148  }
1149  }
1150 #ifdef SWIG_DIRECTORS
1151  for (unsigned int j = 0; j < types.size(); ++j)
1152  Swig::erase_rtdir(types[j].second.ptr);
1153 #endif
1154  }
1155 
1156  dim_vector dims(void) const {
1157  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1158 
1159  // Find the __dims__ method of this object
1160  member_value_pair *m = nc_this->find_member("__dims__", false);
1161 
1162  if (!m) return dim_vector(1,1);
1163 
1164  // Call the __dims__ method of this object
1165  octave_value_list inarg;
1166  inarg.append(nc_this->as_value());
1167  octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
1168 
1169  // __dims__ should return (at least) one output argument
1170  if (outarg.length() < 1) return dim_vector(1,1);
1171 
1172  octave_value & out = outarg(0);
1173 
1174  // Return value should be cell or matrix of integers
1175  if (out.is_cell()) {
1176  const Cell & c=out.cell_value();
1177  int ndim = c.rows();
1178  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1179 
1180  dim_vector d;
1181  d.resize(ndim < 2 ? 2 : ndim);
1182  d(0) = d(1) = 1;
1183 
1184  // Fill in dim_vector
1185  for (int k=0;k<ndim;k++) {
1186  const octave_value& obj = c(k);
1187  d.elem(k) = obj.int_value();
1188 
1189  // __dims__ should return a cell filled with integers
1190  if (error_state) return dim_vector(1,1);
1191  }
1192  return d;
1193  } else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1194  if (out.rows()==1 || out.columns()==1) {
1195  Array<int> a = out.int_vector_value();
1196  if (error_state) return dim_vector(1,1);
1197  dim_vector d;
1198  d.resize(a.numel() < 2 ? 2 : a.numel());
1199  d(0) = d(1) = 1;
1200  for (int k=0;k<a.numel();k++) {
1201  d.elem(k) = a(k);
1202  }
1203  return d;
1204  } else {
1205  return dim_vector(1,1);
1206  }
1207  } else {
1208  return dim_vector(1,1);
1209  }
1210  }
1211 
1212  octave_value as_value() {
1213  ++count;
1214  return Swig::swig_value_ref(this);
1215  }
1216 
1217  void incref() {
1218  ++count;
1219  }
1220 
1221  void decref() {
1222  if (!--count)
1223  delete this;
1224  }
1225 
1226  long swig_this() const {
1227  if (!types.size())
1228  return (long) this;
1229  return (long) types[0].second.ptr;
1230  }
1231  const char* help_text() const {
1232  if (!types.size())
1233  return 0;
1234  if (!types[0].first->clientdata)
1235  return 0;
1236  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1237  return c->constructor_doc;
1238  }
1239 
1240  std::string swig_type_name() const {
1241  // * need some way to manually name subclasses.
1242  // * eg optional first arg to subclass(), or named_subclass()
1243  std::string ret;
1244  for (unsigned int j = 0; j < types.size(); ++j) {
1245  if (j)
1246  ret += "_";
1247  if (types[j].first->clientdata) {
1248  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1249  ret += c->name;
1250  } else
1251  ret += types[j].first->name;
1252  }
1253  return ret;
1254  }
1255 
1257  rhs.own = 0;
1258  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1259  assert(!rhs.types[j].second.destroyed);
1260 #ifdef SWIG_DIRECTORS
1261  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1262  if (d)
1263  Swig::swig_director_set_self(d, this);
1264 #endif
1265  }
1266  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1267  members.insert(rhs.members.begin(), rhs.members.end());
1268  rhs.types.clear();
1269  rhs.members.clear();
1270  }
1271 
1272  typedef member_map::const_iterator swig_member_const_iterator;
1275 
1276  void *cast(swig_type_info *type, int *_own, int flags) {
1277  if (_own)
1278  *_own = own;
1279  if (flags &SWIG_POINTER_DISOWN)
1280  own = 0;
1281  if (!type && types.size())
1282  return types[0].second.ptr;
1283  for (unsigned int j = 0; j < types.size(); ++j)
1284  if (type == types[j].first)
1285  return types[j].second.ptr;
1286  for (unsigned int j = 0; j < types.size(); ++j) {
1287  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1288  if (!tc)
1289  continue;
1290  int newmemory = 0;
1291  void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1292  assert(!newmemory); // newmemory handling not yet implemented
1293  return vptr;
1294  }
1295  return 0;
1296  }
1297 
1298  bool is_owned() const {
1299  return own;
1300  }
1301 
1302 #ifdef SWIG_DIRECTORS
1303  void director_destroyed(Swig::Director *d) {
1304  bool found = false;
1305  for (unsigned int j = 0; j < types.size(); ++j) {
1306  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1307  if (dj == d) {
1308  types[j].second.destroyed = true;
1309  found = true;
1310  }
1311  }
1312  assert(found);
1313  }
1314 #endif
1315 
1316  void assign(const std::string &name, const octave_value &ov) {
1317  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1318  }
1319 
1320  void assign(const std::string &name, const swig_octave_member *m) {
1321  members[name] = std::make_pair(m, octave_value());
1322  }
1323 
1324  octave_base_value *clone() const {
1325  // pass-by-value is probably not desired, and is harder;
1326  // requires calling copy constructors of contained types etc.
1327  assert(0);
1328  *(int *) 0 = 0;
1329  return 0;
1330  }
1331 
1332  octave_base_value *empty_clone() const {
1333  return new octave_swig_type();
1334  }
1335 
1336  bool is_defined() const {
1337  return true;
1338  }
1339 
1340  virtual bool is_map() const {
1341  return true;
1342  }
1343 
1344  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1345  octave_value_list ovl = subsref(ops, idx, 1);
1346  return ovl.length()? ovl(0) : octave_value();
1347  }
1348 
1349  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1350  assert(ops.size() > 0);
1351  assert(ops.size() == idx.size());
1352 
1353  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1354  int skip = 0;
1355  octave_value_list sub_ovl;
1356 
1357  // constructor invocation
1358  if (ops[skip] == '(' && construct_type) {
1359  assert(construct_type->clientdata);
1361  if (!c->constructor) {
1362  error("cannot create instance");
1363  return octave_value_list();
1364  }
1365  octave_value_list args;
1366  if (c->director)
1367  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1368  args.append(*idx_it++);
1369  ++skip;
1370  sub_ovl = c->constructor(args, nargout);
1371  }
1372  // member dereference or invocation
1373  else if (ops[skip] == '.') {
1374  std::string subname;
1375  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1376  for (;;) {
1377  octave_value_list subname_ovl(*idx_it++);
1378  ++skip;
1379  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1380  subname = subname_ovl(0).string_value();
1381 
1382  const swig_type_info *next_base = find_base(subname, base);
1383  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1384  break;
1385  base = next_base;
1386  }
1387 
1388  member_value_pair tmp, *m = &tmp;
1389  if (!base || !(m->first = find_member(base, subname)))
1390  m = find_member(subname, false);
1391  if (!m) {
1392  error("member not found");
1393  return octave_value_list();
1394  }
1395 
1396  octave_value_list args;
1397  if (!always_static &&
1398  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1399  args.append(as_value());
1400  if (skip < (int) ops.size() && ops[skip] == '(' &&
1401  ((m->first && m->first->method) || m->second.is_function() ||
1402  m->second.is_function_handle())) {
1403  args.append(*idx_it++);
1404  ++skip;
1405  sub_ovl = member_invoke(m, args, nargout);
1406  } else {
1407  sub_ovl = member_deref(m, args);
1408  }
1409  }
1410  // index operator
1411  else {
1412  if (ops[skip] == '(' || ops[skip] == '{') {
1413  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1414  octave_value_list args;
1415  args.append(*idx_it++);
1416  ++skip;
1417  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1418  error("error evaluating index operator");
1419  return octave_value_list();
1420  }
1421  } else {
1422  error("unsupported subsref");
1423  return octave_value_list();
1424  }
1425  }
1426 
1427  if (skip >= (int) ops.size())
1428  return sub_ovl;
1429  if (sub_ovl.length() < 1) {
1430  error("bad subs ref");
1431  return octave_value_list();
1432  }
1433  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1434  }
1435 
1436  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1437  assert(ops.size() > 0);
1438  assert(ops.size() == idx.size());
1439 
1440  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1441  int skip = 0;
1442 
1443  if (ops.size() > 1) {
1444  std::list < octave_value_list >::const_iterator last = idx.end();
1445  --last;
1446  std::list < octave_value_list > next_idx(idx.begin(), last);
1447  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1448  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1449  }
1450 
1451  else if (ops[skip] == '(' || ops[skip] == '{') {
1452  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1453  member_value_pair *m = find_member(op_name, false);
1454  if (m) {
1455  octave_value_list args;
1456  args.append(as_value());
1457  args.append(*idx_it);
1458  args.append(rhs);
1459  member_invoke(m, args, 1);
1460  } else
1461  error("%s member not found", op_name);
1462  }
1463 
1464  else if (ops[skip] == '.') {
1465  octave_value_list subname_ovl(*idx_it++);
1466  ++skip;
1467  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1468  std::string subname = subname_ovl(0).string_value();
1469 
1470  member_value_pair *m = find_member(subname, true);
1471  if (!m->first || !m->first->set_method) {
1472  m->first = 0;
1473  m->second = rhs;
1474  } else if (m->first->set_method) {
1475  octave_value_list args;
1476  if (!m->first->is_static() && !m->first->is_global())
1477  args.append(as_value());
1478  args.append(rhs);
1479  m->first->set_method(args, 1);
1480  } else
1481  error("member not assignable");
1482  } else
1483  error("unsupported subsasgn");
1484 
1485  return as_value();
1486  }
1487 
1488  virtual bool is_object() const {
1489  return true;
1490  }
1491 
1492  virtual bool is_string() const {
1493  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1494  return !!nc_this->find_member("__str__", false);
1495  }
1496 
1497  virtual std::string string_value(bool force = false) const {
1498  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1499  member_value_pair *m = nc_this->find_member("__str__", false);
1500  if (!m) {
1501  error("__str__ method not defined");
1502  return std::string();
1503  }
1504  octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
1505  if (outarg.length() < 1 || !outarg(0).is_string()) {
1506  error("__str__ method did not return a string");
1507  return std::string();
1508  }
1509  return outarg(0).string_value();
1510  }
1511 
1512 #if OCTAVE_API_VERSION_NUMBER >= 40
1513  virtual octave_map map_value() const {
1514  return octave_map();
1515  }
1516 #else
1517  virtual Octave_map map_value() const {
1518  return Octave_map();
1519  }
1520 #endif
1521 
1522  virtual string_vector map_keys() const {
1523  member_map tmp;
1524  load_members(tmp);
1525 
1526  string_vector keys(tmp.size());
1527  int k = 0;
1528  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1529  keys(k++) = it->first;
1530 
1531  return keys;
1532  }
1533 
1534  virtual bool save_ascii (std::ostream& os) {
1535  return true;
1536  }
1537 
1538  virtual bool load_ascii (std::istream& is) {
1539  return true;
1540  }
1541 
1542  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1543  return true;
1544  }
1545 
1546  virtual bool load_binary (std::istream& is, bool swap,
1547  oct_mach_info::float_format fmt) {
1548  return true;
1549  }
1550 
1551 #if defined (HAVE_HDF5)
1552  virtual bool
1553  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1554  return true;
1555  }
1556 
1557  virtual bool
1558  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1559  return true;
1560  }
1561 #endif
1562 
1563  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1564  return string_value();
1565  }
1566 
1567  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1568  return string_value();
1569  }
1570 
1571  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1572  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1573  // (rather than any module namespace).
1574 
1575  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1576  if (!fcn)
1577  return false;
1578  ret = fcn->do_multi_index_op(1, args)(0);
1579  return true;
1580  }
1581 
1582  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1584  assert(ost);
1585 
1586  octave_value ret;
1587  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1588  return ret;
1589  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1590  octave_value_list args;
1591  args.append(make_value_hack(x));
1592  if (dispatch_global_op(symbol, args, ret))
1593  return ret;
1594 
1595  error("could not dispatch unary operator");
1596  return octave_value();
1597  }
1598 
1599  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1600  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1601  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1602 
1603  octave_value ret;
1604  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1605  return ret;
1606  if (rhs_ost) {
1607  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1608  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1609  return ret;
1610  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1611  return ret;
1612  }
1613  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1614  return ret;
1615  }
1616 
1617  std::string symbol;
1618  octave_value_list args;
1619  args.append(make_value_hack(lhs));
1620  args.append(make_value_hack(rhs));
1621 
1622  symbol = SWIG_op_prefix;
1623  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1624  symbol += "_";
1625  symbol += op_name;
1626  symbol += "_";
1627  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1628  if (dispatch_global_op(symbol, args, ret))
1629  return ret;
1630 
1631  symbol = SWIG_op_prefix;
1632  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1633  symbol += "_";
1634  symbol += op_name;
1635  symbol += "_";
1636  symbol += "any";
1637  if (dispatch_global_op(symbol, args, ret))
1638  return ret;
1639 
1640  symbol = SWIG_op_prefix;
1641  symbol += "any";
1642  symbol += "_";
1643  symbol += op_name;
1644  symbol += "_";
1645  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1646  if (dispatch_global_op(symbol, args, ret))
1647  return ret;
1648 
1649  error("could not dispatch binary operator");
1650  return octave_value();
1651  }
1652 
1653  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1654  if (is_string()) {
1655  os << string_value();
1656  return;
1657  }
1658 
1659  member_map tmp;
1660  load_members(tmp);
1661 
1662  indent(os);
1663  os << "{"; newline(os);
1664  increment_indent_level();
1665  for (unsigned int j = 0; j < types.size(); ++j) {
1666  indent(os);
1667  if (types[j].first->clientdata) {
1668  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1669  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1670  } else {
1671  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1672  }
1673  }
1674  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1675  indent(os);
1676  if (it->second.first) {
1677  const char *objtype = it->second.first->method ? "method" : "variable";
1678  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1679  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1680  assert(it->second.first->name == it->first);
1681  } else {
1682  os << it->first; newline(os);
1683  }
1684  }
1685  decrement_indent_level();
1686  indent(os);
1687  os << "}"; newline(os);
1688  }
1689  };
1690 
1691  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1692  // will call clone() via make_unique() if there is more than one outstanding
1693  // reference to the lhs, and forces the clone's reference count to 1
1694  // (so you can't just increment your own count and return this).
1695  //
1696  // One way to fix this (without modifying Octave) is to add a level of
1697  // indirection such that clone copies ref-counted pointer and we keep
1698  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1699  //
1700  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1701  // might be nice.
1702 
1703  class octave_swig_ref:public octave_base_value {
1705  public:
1707  :ptr(_ptr) { }
1708 
1710  { if (ptr) ptr->decref(); }
1711 
1713  { return ptr; }
1714 
1715  octave_base_value *clone() const
1716  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1717 
1718  octave_base_value *empty_clone() const
1719  { return new octave_swig_ref(0); }
1720 
1721  dim_vector dims(void) const
1722  { return ptr->dims(); }
1723 
1724  bool is_defined() const
1725  { return ptr->is_defined(); }
1726 
1727  virtual bool is_map() const
1728  { return ptr->is_map(); }
1729 
1730  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1731  { return ptr->subsref(ops, idx); }
1732 
1733  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1734  { return ptr->subsref(ops, idx, nargout); }
1735 
1736  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1737  { return ptr->subsasgn(ops, idx, rhs); }
1738 
1739  virtual bool is_object() const
1740  { return ptr->is_object(); }
1741 
1742  virtual bool is_string() const
1743  { return ptr->is_string(); }
1744 
1745  virtual std::string string_value(bool force = false) const
1746  { return ptr->string_value(force); }
1747 
1748 #if OCTAVE_API_VERSION_NUMBER >= 40
1749  virtual octave_map map_value() const
1750  { return ptr->map_value(); }
1751 #else
1752  virtual Octave_map map_value() const
1753  { return ptr->map_value(); }
1754 #endif
1755 
1756  virtual string_vector map_keys() const
1757  { return ptr->map_keys(); }
1758 
1759  virtual bool save_ascii (std::ostream& os)
1760  { return ptr->save_ascii(os); }
1761 
1762  virtual bool load_ascii (std::istream& is)
1763  { return ptr->load_ascii(is); }
1764 
1765  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
1766  { return ptr->save_binary(os, save_as_floats); }
1767 
1768  virtual bool load_binary (std::istream& is, bool swap,
1769  oct_mach_info::float_format fmt)
1770  { return ptr->load_binary(is, swap, fmt); }
1771 
1772 #if defined (HAVE_HDF5)
1773  virtual bool
1774  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
1775  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
1776 
1777  virtual bool
1778  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
1779  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1780 #endif
1781 
1782  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
1783  { return ptr->convert_to_str(pad, force, type); }
1784 
1785  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
1786  { return ptr->convert_to_str_internal(pad, force, type); }
1787 
1788  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1789  { return ptr->print(os, pr_as_read_syntax); }
1790 
1791  private:
1794  };
1796  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
1797 
1798  class octave_swig_packed:public octave_base_value {
1800  std::vector < char > buf;
1801  public:
1802 
1803  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
1804  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1805  }
1806 
1807  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
1808  if (outtype && outtype != type)
1809  return false;
1810  assert(sz <= buf.size());
1811  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
1812  return true;
1813  }
1814 
1815  octave_base_value *clone() const {
1816  return new octave_swig_packed(*this);
1817  }
1818 
1819  octave_base_value *empty_clone() const {
1820  return new octave_swig_packed();
1821  }
1822 
1823  bool is_defined() const {
1824  return true;
1825  }
1826 
1827  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1828  indent(os);
1829  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
1830  }
1831 
1832 
1833  virtual bool save_ascii (std::ostream& os) {
1834  return true;
1835  }
1836 
1837  virtual bool load_ascii (std::istream& is) {
1838  return true;
1839  }
1840 
1841  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1842  return true;
1843  }
1844 
1845  virtual bool load_binary (std::istream& is, bool swap,
1846  oct_mach_info::float_format fmt) {
1847  return true;
1848  }
1849 
1850 #if defined (HAVE_HDF5)
1851  virtual bool
1852  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1853  return true;
1854  }
1855 
1856  virtual bool
1857  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1858  return true;
1859  }
1860 #endif
1861 
1862  private:
1865  };
1867  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
1868 
1869  static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
1870  error("attempt to set immutable member variable");
1871  return octave_value_list();
1872  }
1873 
1875  const octave_value_list &ovl;
1876  int j;
1877 
1878  octave_value_ref(const octave_value_list &_ovl, int _j)
1879  :ovl(_ovl), j(_j) { }
1880 
1881  operator octave_value() const {
1882  return ovl(j);
1883  }
1884 
1885  octave_value operator*() const {
1886  return ovl(j);
1887  }
1888  };
1889 
1890 
1891 namespace Swig {
1892 
1893  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
1894  return new octave_swig_ref(ost);
1895  }
1896 
1898  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1899  ov = ov.cell_value()(0);
1900  return swig_value_deref(*ov.internal_rep());
1901  }
1902 
1903  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
1904  if (ov.type_id() != octave_swig_ref::static_type_id())
1905  return 0;
1906  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
1907  return osr->get_ptr();
1908  }
1909 
1910 }
1911 
1912 
1913 #define swig_unary_op(name) \
1914 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1915  return octave_swig_type::dispatch_unary_op(x,#name); \
1916 }
1917 #define swig_binary_op(name) \
1918 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1919  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1920 }
1921 #define swigreg_unary_op(name) \
1922 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1923 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1924 #define swigreg_binary_op(name) \
1925 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1926 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1927 
1928  swig_unary_op(not);
1929  swig_unary_op(uplus);
1930  swig_unary_op(uminus);
1931  swig_unary_op(transpose);
1932  swig_unary_op(hermitian);
1933  swig_unary_op(incr);
1934  swig_unary_op(decr);
1935 
1936  swig_binary_op(add);
1937  swig_binary_op(sub);
1938  swig_binary_op(mul);
1939  swig_binary_op(div);
1940  swig_binary_op(pow);
1941  swig_binary_op(ldiv);
1942  swig_binary_op(lshift);
1943  swig_binary_op(rshift);
1944  swig_binary_op(lt);
1945  swig_binary_op(le);
1946  swig_binary_op(eq);
1947  swig_binary_op(ge);
1948  swig_binary_op(gt);
1949  swig_binary_op(ne);
1950  swig_binary_op(el_mul);
1951  swig_binary_op(el_div);
1952  swig_binary_op(el_pow);
1953  swig_binary_op(el_ldiv);
1954  swig_binary_op(el_and);
1955  swig_binary_op(el_or);
1956 
1958  swigreg_unary_op(not);
1959  swigreg_unary_op(uplus);
1960  swigreg_unary_op(uminus);
1961  swigreg_unary_op(transpose);
1962  swigreg_unary_op(hermitian);
1963  swigreg_unary_op(incr);
1964  swigreg_unary_op(decr);
1965  }
1966  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
1967  swigreg_binary_op(add);
1968  swigreg_binary_op(sub);
1969  swigreg_binary_op(mul);
1970  swigreg_binary_op(div);
1971  swigreg_binary_op(pow);
1972  swigreg_binary_op(ldiv);
1973  swigreg_binary_op(lshift);
1974  swigreg_binary_op(rshift);
1975  swigreg_binary_op(lt);
1976  swigreg_binary_op(le);
1977  swigreg_binary_op(eq);
1978  swigreg_binary_op(ge);
1979  swigreg_binary_op(gt);
1980  swigreg_binary_op(ne);
1981  swigreg_binary_op(el_mul);
1982  swigreg_binary_op(el_div);
1983  swigreg_binary_op(el_pow);
1984  swigreg_binary_op(el_ldiv);
1985  swigreg_binary_op(el_and);
1986  swigreg_binary_op(el_or);
1987  }
1989  // here we assume that tid are conseq integers increasing from zero, and
1990  // that our tid is the last one. might be better to have explicit string
1991  // list of types we should bind to, and use lookup_type to resolve their tid.
1992 
1993  SWIG_InstallUnaryOps(tid);
1994  SWIG_InstallBinaryOps(tid, tid);
1995  for (int j = 0; j < tid; ++j) {
1996  SWIG_InstallBinaryOps(j, tid);
1997  SWIG_InstallBinaryOps(tid, j);
1998  }
1999  }
2000 
2001 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2002  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2003 
2004 #ifdef SWIG_DIRECTORS
2005  Swig::Director *d = Swig::get_rtdir(ptr);
2006  if (d && Swig::swig_director_get_self(d))
2007  return Swig::swig_director_get_self(d)->as_value();
2008 #endif
2009  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2010 }
2011 
2012 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2013  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2014  ov = ov.cell_value()(0);
2015  if (!ov.is_defined() ||
2016  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2017  if (ptr)
2018  *ptr = 0;
2019  return SWIG_OK;
2020  }
2021  if (ov.type_id() != octave_swig_ref::static_type_id())
2022  return SWIG_ERROR;
2023  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2024  octave_swig_type *ost = osr->get_ptr();
2025  void *vptr = ost->cast(type, own, flags);
2026  if (!vptr)
2027  return SWIG_ERROR;
2028  if (ptr)
2029  *ptr = vptr;
2030  return SWIG_OK;
2031 }
2032 
2033 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2034  return new octave_swig_packed(type, (char *) ptr, sz);
2035 }
2036 
2037 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2038  if (!ov.is_defined())
2039  return SWIG_ERROR;
2040  if (ov.type_id() != octave_swig_packed::static_type_id())
2041  return SWIG_ERROR;
2042  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2043  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2044 }
2045 
2046 void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2047  module_ns->assign(name, ov);
2048 }
2049 
2050 SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
2051  return get_global_value(name, true);
2052 }
2053 
2054 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2055  // It is critical that a newly-allocated octave_value is passed to set_global_value(),
2056  // since it and the Octave symbol table take references to the values assigned to it.
2057  // If we were to pass a reference to 'value' to set_global_value(), then the Octave
2058  // symbol table would hold a reference to a variable owned by the SWIG .oct module.
2059  // Both will think that they own the reference (since the .oct module is dynamically
2060  // loaded, it appears to have its own C++ runtime), and so they will both try to
2061  // de-allocate the octave_value on exit, resulting in a double-free or seg-fault.
2062  // This is prevented by giving Octave its own heap-allocated copy of 'value'.
2063  octave_value *pov = new octave_value(value);
2064  set_global_value(name, *pov);
2065 }
2066 
2068 #if OCTAVE_API_VERSION_NUMBER < 37
2069  link_to_global_variable(curr_sym_tab->lookup(name, true));
2070 #else
2071  symbol_table::varref(name);
2072  symbol_table::mark_global(name);
2073 #endif
2074 }
2075 
2077  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2078  if (!ov.is_defined() ||
2079  ov.type_id() != octave_swig_packed::static_type_id())
2080  return 0;
2081  const octave_swig_packed* osp =
2082  static_cast < const octave_swig_packed *> (ov.internal_rep());
2083  swig_module_info *pointer = 0;
2084  osp->copy(0, &pointer, sizeof(swig_module_info *));
2085  return pointer;
2086 }
2087 
2088 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2089  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2091 }
2092 
2093 
2094 
2095 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2096 
2097 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2098 
2099 
2100 
2101 /* -------- TYPES TABLE (BEGIN) -------- */
2102 
2103 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2104 #define SWIGTYPE_p_char swig_types[1]
2105 #define SWIGTYPE_p_double swig_types[2]
2106 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2107 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2108 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2109 #define SWIGTYPE_p_int swig_types[6]
2110 #define SWIGTYPE_p_p_char swig_types[7]
2111 #define SWIGTYPE_p_unsigned_int swig_types[8]
2113 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2114 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2115 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2116 
2117 /* -------- TYPES TABLE (END) -------- */
2118 
2119 
2120 #define SWIGVERSION 0x020007
2121 #define SWIG_VERSION SWIGVERSION
2122 
2123 
2124 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2125 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2126 
2127 
2128 #include <stdexcept>
2129 
2130 
2131 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2132 #undef PACKAGE
2133 #undef VERSION
2134 
2135 #include "plplotP.h"
2136 
2137 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2138 #ifdef OCTAVE_EXPORT
2139  #if defined ( __GNUC__ ) && __GNUC__ > 3
2140  #undef OCTAVE_EXPORT
2141  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2142  #endif
2143 #endif
2144 
2145 
2146 
2147 // I hate global variables but this is the best way I can think of
2148 // to manage consistency checking among function arguments.
2149  static PLINT Alen = 0;
2150  static PLINT Xlen = 0, Ylen = 0;
2151 
2152 
2153 // Convenience functions copied from matwrap-based approach (currently
2154 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2155 // tricky scalar case and also adopted so that the resulting
2156 // swig-generated source code will look similar to the matwrap-generated
2157 // source code.
2158 
2159  inline int max( int a, int b )
2160  {
2161  return a >= b ? a : b;
2162  }
2163  inline int min( int a, int b )
2164  {
2165  return a >= b ? a : b;
2166  }
2167 
2168 //
2169 // Function to get the total length (rows*columns) of an octave object of
2170 // arbitrary type.
2171 // Arguments:
2172 // 1) The octave object.
2173 //
2174 // If the object is a scalar, the array length is 1.
2175 //
2176  static int
2177  _arraylen( const octave_value &o_obj )
2178  {
2179  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2180  // max is necessary because sometimes
2181  // rows() or columns() return -1 or 0 for
2182  // scalars.
2183  }
2184 
2185 //
2186 // Function to get the number of dimensions of an object.
2187 //
2188  static int
2189  _n_dims( const octave_value &o_obj )
2190  {
2191  if ( max( o_obj.columns(), 1 ) > 1 )
2192  return 2;
2193  // max is necessary because sometimes
2194  // rows() or columns() return -1 or 0 for
2195  // scalars.
2196  else if ( max( o_obj.rows(), 1 ) > 1 )
2197  return 1;
2198  else
2199  return 0;
2200  }
2201 
2202 //
2203 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2204 //
2205  static inline int
2206  _dim( const octave_value &o_obj, int dim_idx )
2207  {
2208  if ( dim_idx == 0 )
2209  return max( o_obj.rows(), 0 );
2210  // max is necessary because sometimes
2211  // rows() or columns() return -1 or 0 for
2212  // scalars.
2213  else if ( dim_idx == 1 )
2214  return max( o_obj.columns(), 0 );
2215  else
2216  return 1;
2217  }
2218 
2219 //
2220 // The following function converts an array of doubles into some other
2221 // numeric type. Arguments:
2222 // 1) Where to store the result. The type is determined from the type of
2223 // this pointer.
2224 // 2) A vector of doubles to convert.
2225 // 3) The number of doubles.
2226 //
2227  template <class FLOAT>
2228  static inline void
2229  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2230  {
2231  while ( n_el-- > 0 )
2232  *out_arr++ = (FLOAT) ( *in_arr++ );
2233  }
2234 
2235  template void _cvt_double_to( int *, double *, unsigned );
2236  template void _cvt_double_to( unsigned *, double *, unsigned );
2237  template void _cvt_double_to( long *, double *, unsigned );
2238  template void _cvt_double_to( unsigned long *, double *, unsigned );
2239  template void _cvt_double_to( short *, double *, unsigned );
2240  template void _cvt_double_to( unsigned short *, double *, unsigned );
2241  template void _cvt_double_to( float *, double *, unsigned );
2242  // Instantiate our templates. Octave uses
2243  // manual template instantiation.
2244 
2245 //
2246 // Convert an array of some other type into an array of doubles. Arguments:
2247 // 1) The array of objects of other type.
2248 // 2) The output array of doubles.
2249 // 3) The number of elements to convert.
2250 //
2251  template <class FLOAT>
2252  static inline void
2253  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2254  {
2255  while ( n_el-- > 0 )
2256  *d_arr++ = double(*arr++);
2257  }
2258 
2259  template void _cvt_to_double( int *, double *, unsigned );
2260  template void _cvt_to_double( unsigned *, double *, unsigned );
2261  template void _cvt_to_double( long *, double *, unsigned );
2262  template void _cvt_to_double( unsigned long *, double *, unsigned );
2263  template void _cvt_to_double( short *, double *, unsigned );
2264  template void _cvt_to_double( unsigned short *, double *, unsigned );
2265  template void _cvt_to_double( float *, double *, unsigned );
2266  // Instantiate our templates. Octave uses
2267  // manual template instantiation.
2268 
2269 
2270  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2271  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2272  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2273  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2274  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2276  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2277 
2278 
2279 #include <iostream>
2280 
2281  octave_function *fcnMapForm;
2282  std::string nameMapForm;
2283 
2284  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2285  {
2286  octave_idx_type i;
2287  octave_value_list functionArguments;
2288  octave_value_list retval;
2289 
2290  Matrix xin( n, 1 );
2291  Matrix yin( n, 1 );
2292  Matrix xout;
2293  Matrix yout;
2294 
2295  for ( i = 0; i < n; i++ )
2296  {
2297  xin( i, 0 ) = x[i];
2298  yin( i, 0 ) = y[i];
2299  }
2300 
2301  functionArguments( 0 ) = xin;
2302  functionArguments( 1 ) = yin;
2303 
2304  if ( fcnMapForm != NULL )
2305  retval = feval( fcnMapForm, functionArguments, 1 );
2306  else
2307  retval = feval( nameMapForm, functionArguments, 1 );
2308 
2309 
2310  if ( retval.length() >= 2 )
2311  {
2312  xout = retval( 0 ).matrix_value();
2313  yout = retval( 1 ).matrix_value();
2314 
2315  for ( i = 0; i < n; i++ )
2316  {
2317  x[i] = xout( i, 0 );
2318  y[i] = yout( i, 0 );
2319  }
2320  }
2321  }
2322 
2323 
2324  octave_function *fcnLabelFunc;
2325  std::string nameLabelFunc;
2326 
2327  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2328  {
2329  int i;
2330  octave_value_list functionArguments;
2331  octave_value_list retval;
2332 
2333  Matrix inAxis( 1, 1 );
2334  Matrix inValue( 1, 1 );
2335  inAxis( 0, 0 ) = axis;
2336  inValue( 0, 0 ) = value;
2337 
2338  functionArguments( 0 ) = inAxis;
2339  functionArguments( 1 ) = inValue;
2340 
2341  if ( fcnLabelFunc != NULL )
2342  retval = feval( fcnLabelFunc, functionArguments, 1 );
2343  else
2344  retval = feval( nameLabelFunc, functionArguments, 1 );
2345 
2346  strncpy( label, retval( 0 ).string_value().c_str(), length );
2347  }
2348 
2349 
2350  octave_function *fcnCoordTrans;
2351  std::string nameCoordTrans;
2352 
2353  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2354  {
2355  octave_idx_type i;
2356  octave_value_list functionArguments;
2357  octave_value_list retval;
2358 
2359  Matrix xin( 1, 1 );
2360  Matrix yin( 1, 1 );
2361  Matrix xout;
2362  Matrix yout;
2363 
2364  xin( 0, 0 ) = x;
2365  yin( 0, 0 ) = y;
2366 
2367  functionArguments( 0 ) = xin;
2368  functionArguments( 1 ) = yin;
2369 
2370  if ( fcnCoordTrans != NULL )
2371  retval = feval( fcnCoordTrans, functionArguments, 1 );
2372  else
2373  retval = feval( nameCoordTrans, functionArguments, 1 );
2374 
2375 
2376  if ( retval.length() >= 2 )
2377  {
2378  xout = retval( 0 ).matrix_value();
2379  yout = retval( 1 ).matrix_value();
2380 
2381  *xt = xout( 0, 0 );
2382  *yt = yout( 0, 0 );
2383  }
2384  }
2385 
2386 
2387  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2388  {
2389  PLINT i;
2390  printf( "nlegend =%d\n", nlegend );
2391  for ( i = 0; i < nlegend; i++ )
2392  {
2393  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2394  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2395  printf( "text[%d] =%s\n", i, text[i] );
2396  }
2397  }
2398 
2399 
2400 #include <limits.h>
2401 #if !defined(SWIG_NO_LLONG_MAX)
2402 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2403 # define LLONG_MAX __LONG_LONG_MAX__
2404 # define LLONG_MIN (-LLONG_MAX - 1LL)
2405 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2406 # endif
2407 #endif
2408 
2409 
2410  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2411  {
2412  if (!ov.is_scalar_type())
2413  return SWIG_TypeError;
2414  if (ov.is_complex_scalar())
2415  return SWIG_TypeError;
2416  if (ov.is_double_type()||ov.is_single_type()) {
2417  double v=ov.double_value();
2418  if (v!=floor(v))
2419  return SWIG_TypeError;
2420  }
2421  if (val)
2422  *val = ov.long_value();
2423  return SWIG_OK;
2424  }
2425 
2426 
2427 SWIGINTERN int
2428 SWIG_AsVal_int (octave_value obj, int *val)
2429 {
2430  long v;
2431  int res = SWIG_AsVal_long (obj, &v);
2432  if (SWIG_IsOK(res)) {
2433  if ((v < INT_MIN || v > INT_MAX)) {
2434  return SWIG_OverflowError;
2435  } else {
2436  if (val) *val = (int)(v);
2437  }
2438  }
2439  return res;
2440 }
2441 
2442 
2443  static int my_plGetCursor( int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin )
2444  {
2445  PLGraphicsIn gin;
2446  int status; status = plGetCursor( &gin );
2447  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2448  strncpy( string, gin.string, PL_MAXKEY - 1 );
2449  string[PL_MAXKEY - 1] = '\0';
2450 
2451  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2452  return status;
2453  }
2454 
2455 
2456 SWIGINTERN int
2457 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2458 {
2459  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2460  ov = ov.cell_value()(0);
2461  if (!ov.is_string())
2462  return SWIG_TypeError;
2463 
2464  std::string str=ov.string_value();
2465  size_t len=str.size();
2466  char* cstr=(char*)str.c_str();
2467  if (alloc) {
2468  *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2469  *alloc = SWIG_NEWOBJ;
2470  } else if (cptr)
2471  *cptr = cstr;
2472  if (psize)
2473  *psize = len + 1;
2474  return SWIG_OK;
2475 }
2476 
2477 
2478 
2479 
2480 
2482  {
2483  return octave_value(value);
2484  }
2485 
2486 
2487 SWIGINTERNINLINE octave_value
2489 {
2490  return SWIG_From_long (value);
2491 }
2492 
2493 
2495  {
2496  return octave_value(value);
2497  }
2498 
2499 
2500 // Translates relative device coordinates to world coordinates.
2501  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2502  {
2503  PLGraphicsIn gin;
2504  int st;
2505  gin.dX = x_in; gin.dY = y_in;
2506  st = plTranslateCursor( &gin );
2507  *x = gin.wX; *y = gin.wY;
2508  return st;
2509  }
2510 
2511 
2512  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2513  {
2514  if (!ov.is_scalar_type())
2515  return SWIG_TypeError;
2516  if (ov.is_complex_scalar())
2517  return SWIG_TypeError;
2518  if (val)
2519  *val = ov.double_value();
2520  return SWIG_OK;
2521  }
2522 
2523 
2524 // Create 1d stripchart
2525 
2526  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2527  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2528  PLFLT xlpos, PLFLT ylpos,
2529  PLBOOL y_ascl, PLBOOL acc,
2530  PLINT colbox, PLINT collab,
2531  const PLINT *colline, const PLINT *styline,
2532  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2533  const char *labx, const char *laby, const char *labtop )
2534  {
2535  const char *legline[4];
2536  legline[0] = legline1; legline[1] = legline2;
2537  legline[2] = legline3; legline[3] = legline4;
2538  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2539  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2540  labx, laby, labtop );
2541  }
2542 
2543 
2544 // One more hack. As it is not possible (and would not be desirable) to pass
2545 // an Octave function to plcont(), I have defined three plcont():
2546 // plcont uses a defined here xform()
2547 // plcont0 uses pltr0()
2548 // plcont1 uses pltr1()
2549 // plcont2 uses pltr2()
2550 // plcont2p uses pltr2p()
2551 //
2552 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2553 // f2c, which is a #define that does the necessary conversion.
2554 //
2555 
2556  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2557  {
2558  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2559  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2560  }
2561 
2562 // convert from Fortran like arrays (one vector), to C like 2D arrays
2563 
2564 #define f2c( f, ff, nx, ny ) \
2565  PLFLT * *ff; \
2566  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2567  for ( int i = 0; i < nx; i++ ) { \
2568  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2569  for ( int j = 0; j < ny; j++ ) \
2570  *( ff[i] + j ) = *( f + nx * j + i );}
2571 
2572 // simpler plcont() for use with xform()
2573 
2574  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2575  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2576  {
2577  f2c( f, ff, nx, ny );
2578  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2579  }
2580 
2581 // plcont() for use with pltr0() NOT TESTED
2582 
2583  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2584  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2585  {
2586  f2c( f, ff, nx, ny );
2587  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2588  }
2589 
2590 // plcont() for use with pltr1()
2591 
2592  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2593  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2594  {
2595  PLcGrid grid1;
2596  grid1.nx = nx; grid1.ny = ny;
2597  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2598  f2c( f, ff, nx, ny );
2599  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2600  }
2601 
2602 // plcont() for use with pltr2()
2603  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2604  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2605  {
2606  PLcGrid2 grid2;
2607  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2608  grid2.nx = nx; grid2.ny = ny;
2609  grid2.xg = xgg; grid2.yg = ygg;
2610  f2c( f, ff, nx, ny );
2611  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2612  }
2613 
2614 // plcont() for use with pltr2p()
2615 
2616  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2617  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2618  {
2619  PLcGrid2 grid2;
2620  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2621  grid2.nx = nx; grid2.ny = ny;
2622  grid2.xg = xgg; grid2.yg = ygg;
2623  f2c( f, ff, nx, ny );
2624  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2625  }
2626 
2627 
2628  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2629  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2630  PLFLT *zg, int type, PLFLT data )
2631  {
2632  f2c( zg, zgg, nptsx, nptsy );
2633  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2634  for ( int i = 0; i < nptsx; i++ )
2635  for ( int j = 0; j < nptsy; j++ )
2636  *( zg + nptsx * j + i ) = zgg[i][j];
2637  }
2638 
2639 
2640 // Plots a mesh representation of the function z[x][y].
2641 
2642  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2643  {
2644  f2c( z, zz, nx, ny );
2645  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
2646  }
2647 
2648 // Plots a mesh representation of the function z[x][y] with contour
2649 
2650  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2651  {
2652  f2c( z, zz, nx, ny );
2653  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2654  }
2655 
2656 
2657 // Plots a 3-d representation of the function z[x][y].
2658  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2659  PLINT nx, PLINT ny, PLINT opt, PLINT side )
2660  {
2661  f2c( z, zz, nx, ny )
2662  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
2663  }
2664 
2665 // Plots a 3-d representation of the function z[x][y] with contour
2666  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2667  PLINT nx, PLINT ny, PLINT opt,
2668  const PLFLT *clevel, PLINT nlevel )
2669  {
2670  f2c( z, zz, nx, ny )
2671  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2672  }
2673 
2674 
2675  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2676  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2677  {
2678  f2c( z, zz, nx, ny )
2679  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2680  }
2681 
2682 
2683 // The same as in plcont. I have hardcoded the first function pointer
2684 // to plfill(). The second function pointer will use the same convention
2685 // as in plcont().
2686 //
2687 
2688 // the simpler plshade()
2689  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
2690  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2691  PLFLT shade_min, PLFLT shade_max,
2692  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2693  PLINT min_color, PLINT min_width,
2694  PLINT max_color, PLINT max_width,
2695  PLINT rectangular, PLFLT *tr )
2696  {
2697  f2c( a, aa, nx, ny );
2698  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2699  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2700  min_color, min_width, max_color, max_width,
2701  plfill, rectangular, xform, tr );
2702  }
2703 
2704 // plshade() for use with pltr1
2705  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2706  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2707  PLFLT shade_min, PLFLT shade_max,
2708  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2709  PLINT min_color, PLINT min_width,
2710  PLINT max_color, PLINT max_width,
2711  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2712  {
2713  PLcGrid grid1;
2714  grid1.nx = nx; grid1.ny = ny;
2715  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2716  f2c( a, aa, nx, ny );
2717  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2718  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2719  min_color, min_width, max_color, max_width,
2720  plfill, rectangular, pltr1, &grid1 );
2721  }
2722 
2723 // plshade() for use with pltr2
2724  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2725  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2726  PLFLT shade_min, PLFLT shade_max,
2727  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2728  PLINT min_color, PLINT min_width,
2729  PLINT max_color, PLINT max_width,
2730  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2731  {
2732  PLcGrid2 grid2;
2733  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2734  grid2.nx = nx; grid2.ny = ny;
2735  grid2.xg = xgg; grid2.yg = ygg;
2736  f2c( a, aa, nx, ny );
2737  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2738  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2739  min_color, min_width, max_color, max_width,
2740  plfill, rectangular, pltr2, &grid2 );
2741  }
2742 
2743 
2744 
2745  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
2746  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2747  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2748  PLINT cont_color, PLINT cont_width,
2749  PLINT rectangular )
2750  {
2751  f2c( a, aa, nx, ny );
2752  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2753  clevel, nlevel, fill_width, cont_color, cont_width,
2754  plfill, rectangular, NULL, NULL );
2755  }
2756 
2757  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
2758  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2759  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2760  PLINT cont_color, PLINT cont_width,
2761  PLINT rectangular, PLFLT *tr )
2762  {
2763  f2c( a, aa, nx, ny );
2764  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2765  clevel, nlevel, fill_width, cont_color, cont_width,
2766  plfill, rectangular, xform, tr );
2767  }
2768 
2769  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
2770  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2771  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2772  PLINT cont_color, PLINT cont_width,
2773  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2774  {
2775  PLcGrid grid1;
2776  grid1.nx = nx; grid1.ny = ny;
2777  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2778 
2779  f2c( a, aa, nx, ny );
2780  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2781  clevel, nlevel, fill_width, cont_color, cont_width,
2782  plfill, rectangular, pltr1, &grid1 );
2783  }
2784 
2785  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
2786  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2787  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2788  PLINT cont_color, PLINT cont_width,
2789  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2790  {
2791  PLcGrid2 grid2;
2792  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2793  grid2.nx = nx; grid2.ny = ny;
2794  grid2.xg = xgg; grid2.yg = ygg;
2795  f2c( a, aa, nx, ny );
2796  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2797  clevel, nlevel, fill_width, cont_color, cont_width,
2798  plfill, rectangular, pltr2, &grid2 );
2799  }
2800 
2801 
2802 // Plot an array of vector arrows - uses the same function pointer
2803 // convention as plcont
2804 
2805  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2806  {
2807  f2c( u, uu, nx, ny );
2808  f2c( v, vv, nx, ny );
2809  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
2810  }
2811 
2812 // plvect() for use with pltr1
2813  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2814  {
2815  PLcGrid grid1;
2816  grid1.nx = nx; grid1.ny = ny;
2817  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2818  f2c( u, uu, nx, ny );
2819  f2c( v, vv, nx, ny );
2820  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
2821  }
2822 
2823 // plvect() for use with pltr2
2824  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2825  {
2826  PLcGrid2 grid2;
2827  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2828  grid2.nx = nx; grid2.ny = ny;
2829  grid2.xg = xgg; grid2.yg = ygg;
2830  f2c( u, uu, nx, ny );
2831  f2c( v, vv, nx, ny );
2832  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
2833  }
2834 
2835 
2836 // Plot an image with distortion - uses the same function pointer
2837  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
2838  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2839  PLFLT zmin, PLFLT zmax,
2840  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2841  {
2842  f2c( a, aa, nx, ny );
2843  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2844  }
2845 
2846 // Plot an image with distortion - uses the same function pointer
2847 // convention as plcont
2848  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
2849  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2850  PLFLT zmin, PLFLT zmax,
2851  PLFLT valuemin, PLFLT valuemax )
2852  {
2853  f2c( a, aa, nx, ny );
2854  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2855  }
2856 
2857  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
2858  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2859  PLFLT zmin, PLFLT zmax,
2860  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2861  {
2862  f2c( a, aa, nx, ny );
2863  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
2864  }
2865 
2866 // plimagefr() for use with pltr1
2867  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
2868  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2869  PLFLT zmin, PLFLT zmax,
2870  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2871  {
2872  PLcGrid grid1;
2873  grid1.nx = nx + 1; grid1.ny = ny + 1;
2874  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2875  f2c( a, aa, nx, ny );
2876  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
2877  }
2878 
2879 // plimagefr() for use with pltr2
2880  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
2881  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2882  PLFLT zmin, PLFLT zmax,
2883  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2884  {
2885  PLcGrid2 grid2;
2886  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) ); f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2887  grid2.nx = nx + 1; grid2.ny = ny + 1;
2888  grid2.xg = xgg; grid2.yg = ygg;
2889  f2c( a, aa, nx, ny );
2890  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
2891  }
2892 
2893 
2894 
2895  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
2896  PLINT opt, PLINT position, PLFLT x, PLFLT y,
2897  PLFLT x_length, PLFLT y_length,
2898  PLINT bg_color, PLINT bb_color, PLINT bb_style,
2899  PLFLT low_cap_color, PLFLT high_cap_color,
2900  PLINT cont_color, PLFLT cont_width,
2901  PLINT n_labels, const PLINT *label_opts, const char **label,
2902  PLINT n_axes, const char ** axis_opts,
2903  const PLFLT *ticks, const PLINT *sub_ticks,
2904  const PLINT *n_values, const PLFLT *a )
2905  {
2906  PLINT nx, ny, i;
2907  nx = n_axes;
2908  ny = -1;
2909  for ( i = 0; i < nx; i++ )
2910  if ( n_values[i] > ny )
2911  ny = n_values[i];
2912  f2c( a, aa, nx, ny );
2913  c_plcolorbar( p_colorbar_width, p_colorbar_height,
2914  opt, position, x, y,
2915  x_length, y_length,
2916  bg_color, bb_color, bb_style,
2917  low_cap_color, high_cap_color,
2918  cont_color, cont_width,
2919  n_labels, label_opts, label,
2920  n_axes, axis_opts,
2921  ticks, sub_ticks,
2922  n_values, aa );
2923  }
2924 
2925 
2926 
2927  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
2928  {
2929  if (!ov.is_scalar_type())
2930  return SWIG_TypeError;
2931  if (ov.is_complex_scalar())
2932  return SWIG_TypeError;
2933  if (ov.is_double_type()||ov.is_single_type()) {
2934  double v=ov.double_value();
2935  if (v<0)
2936  return SWIG_OverflowError;
2937  if (v!=floor(v))
2938  return SWIG_TypeError;
2939  }
2940  if (ov.is_int8_type()||ov.is_int16_type()||
2941  ov.is_int32_type()) {
2942  long v=ov.long_value();
2943  if (v<0)
2944  return SWIG_OverflowError;
2945  }
2946  if (ov.is_int64_type()) {
2947  long long v=ov.int64_scalar_value().value();
2948  if (v<0)
2949  return SWIG_OverflowError;
2950  }
2951  if (val)
2952  *val = ov.ulong_value();
2953  return SWIG_OK;
2954  }
2955 
2956 
2957 SWIGINTERN int
2958 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
2959 {
2960  unsigned long v;
2961  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2962  if (SWIG_IsOK(res)) {
2963  if ((v > UINT_MAX)) {
2964  return SWIG_OverflowError;
2965  } else {
2966  if (val) *val = (unsigned int)(v);
2967  }
2968  }
2969  return res;
2970 }
2971 
2972 
2974  {
2975  return octave_value(value);
2976  }
2977 
2978 
2979 SWIGINTERNINLINE octave_value
2981 {
2982  return SWIG_From_unsigned_SS_long (value);
2983 }
2984 
2985 
2986 SWIGINTERN int
2987 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
2988 {
2989  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
2990  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
2991  if (SWIG_IsOK(res)) {
2992  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
2993  if (csize <= size) {
2994  if (val) {
2995  if (csize) memcpy(val, cptr, csize*sizeof(char));
2996  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
2997  }
2998  if (alloc == SWIG_NEWOBJ) {
2999  delete[] cptr;
3000  res = SWIG_DelNewMask(res);
3001  }
3002  return res;
3003  }
3004  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3005  }
3006  return SWIG_TypeError;
3007 }
3008 
3009 
3012 {
3013  static int init = 0;
3014  static swig_type_info* info = 0;
3015  if (!init) {
3016  info = SWIG_TypeQuery("_p_char");
3017  init = 1;
3018  }
3019  return info;
3020 }
3021 
3022 
3023 SWIGINTERNINLINE octave_value
3024 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3025 {
3026  return std::string(carray,carray+size);
3027 }
3028 
3029 
3030 SWIGINTERN int
3031 SWIG_AsVal_char (octave_value obj, char *val)
3032 {
3033  int res = SWIG_AsCharArray(obj, val, 1);
3034  if (!SWIG_IsOK(res)) {
3035  long v;
3036  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3037  if (SWIG_IsOK(res)) {
3038  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3039  if (val) *val = (char)(v);
3040  } else {
3041  res = SWIG_OverflowError;
3042  }
3043  }
3044  }
3045  return res;
3046 }
3047 
3048 const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3049 Specify viewport in absolute coordinates \n\
3050 \n\
3051 DESCRIPTION:\n\
3052 \n\
3053  Alternate routine to plvpor for setting up the viewport. This routine\n\
3054  should be used only if the viewport is required to have a definite\n\
3055  size in millimeters. The routine plgspa is useful for finding out the\n\
3056  size of the current subpage. \n\
3057 \n\
3058  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3059 \n\
3060  This function is used in example 10. \n\
3061 \n\
3062 \n\
3063 \n\
3064 SYNOPSIS:\n\
3065 \n\
3066 plsvpa(xmin, xmax, ymin, ymax)\n\
3067 \n\
3068 ARGUMENTS:\n\
3069 \n\
3070  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3071  viewport from the left-hand edge of the subpage in millimeters. \n\
3072 \n\
3073  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3074  viewport from the left-hand edge of the subpage in millimeters. \n\
3075 \n\
3076  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3077  viewport from the bottom edge of the subpage in millimeters. \n\
3078 \n\
3079  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3080  from the bottom edge of the subpage in millimeters. \n\
3081 ";
3082 const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3083 Write text relative to viewport boundaries in 3D plots. \n\
3084 \n\
3085 DESCRIPTION:\n\
3086 \n\
3087  Writes text at a specified position relative to the viewport\n\
3088  boundaries. Text may be written inside or outside the viewport, but\n\
3089  is clipped at the subpage boundaries. The reference point of a string\n\
3090  lies along a line passing through the string at half the height of a\n\
3091  capital letter. The position of the reference point along this line\n\
3092  is determined by just, and the position of the reference point\n\
3093  relative to the viewport is set by disp and pos. \n\
3094 \n\
3095  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3096 \n\
3097  This function is used in example 28. \n\
3098 \n\
3099 \n\
3100 \n\
3101 SYNOPSIS:\n\
3102 \n\
3103 plmtex3(side, disp, pos, just, text)\n\
3104 \n\
3105 ARGUMENTS:\n\
3106 \n\
3107  side (const char *, input) : Specifies the side of the viewport\n\
3108  along which the text is to be written. The string should contain\n\
3109  one or more of the following characters: [xyz][ps][v]. Only one\n\
3110  label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3111  both the X and Y axes. x: Label the X axis. \n\
3112  y: Label the Y axis. \n\
3113  z: Label the Z axis. \n\
3114  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3115  For X it is the axis that starts at y-min. For Y it is the\n\
3116  axis that starts at x-min. \n\
3117  s: Label the secondary axis. \n\
3118  v: Draw the text perpendicular to the axis. \n\
3119 \n\
3120 \n\
3121  disp (PLFLT, input) : Position of the reference point of string,\n\
3122  measured outwards from the specified viewport edge in units of the\n\
3123  current character height. Use negative disp to write within the\n\
3124  viewport. \n\
3125 \n\
3126  pos (PLFLT, input) : Position of the reference point of string\n\
3127  along the specified edge, expressed as a fraction of the length of\n\
3128  the edge. \n\
3129 \n\
3130  just (PLFLT, input) : Specifies the position of the string relative\n\
3131  to its reference point. If just=0., the reference point is at the\n\
3132  left and if just=1., it is at the right of the string. Other\n\
3133  values of just give intermediate justifications. \n\
3134 \n\
3135  text (const char *, input) : The string to be written out. \n\
3136 ";
3137 const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3138 Set color map1 colors using 8-bit RGB values and double alpha values. \n\
3139 \n\
3140 DESCRIPTION:\n\
3141 \n\
3142  Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3143  documentation) and double alpha values. This also sets the number of\n\
3144  colors.\n\
3145 \n\
3146  This function is used in example 31. \n\
3147 \n\
3148 \n\
3149 \n\
3150 SYNOPSIS:\n\
3151 \n\
3152 plscmap1a(r, g, b, a, ncol1)\n\
3153 \n\
3154 ARGUMENTS:\n\
3155 \n\
3156  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3157  integers (0-255) representing the degree of red in the color. \n\
3158 \n\
3159  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3160  integers (0-255) representing the degree of green in the color. \n\
3161 \n\
3162  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3163  integers (0-255) representing the degree of blue in the color. \n\
3164 \n\
3165  a (PLFLT *, input) : Pointer to array with set of double values\n\
3166  (0.0-1.0) representing the alpha value of the color. \n\
3167 \n\
3168  ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n\
3169  arrays. \n\
3170 ";
3171 const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3172 Select standard viewport \n\
3173 \n\
3174 DESCRIPTION:\n\
3175 \n\
3176  Sets up a standard viewport, leaving a left-hand margin of seven\n\
3177  character heights, and four character heights around the other three\n\
3178  sides. \n\
3179 \n\
3180  Redacted form: plvsta()\n\
3181 \n\
3182  This function is used in examples 1,12,14,17,25,29. \n\
3183 \n\
3184 \n\
3185 \n\
3186 SYNOPSIS:\n\
3187 \n\
3188 plvsta()\n\
3189 ";
3190 const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3191 Switch to graphics screen \n\
3192 \n\
3193 DESCRIPTION:\n\
3194 \n\
3195  Sets an interactive device to graphics mode, used in conjunction with\n\
3196  pltext to allow graphics and text to be interspersed. On a device\n\
3197  which supports separate text and graphics windows, this command causes\n\
3198  control to be switched to the graphics window. If already in graphics\n\
3199  mode, this command is ignored. It is also ignored on devices which\n\
3200  only support a single window or use a different method for shifting\n\
3201  focus. See also pltext. \n\
3202 \n\
3203  Redacted form: plgra()\n\
3204 \n\
3205  This function is used in example 1. \n\
3206 \n\
3207 \n\
3208 \n\
3209 SYNOPSIS:\n\
3210 \n\
3211 plgra()\n\
3212 ";
3213 const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3214 Set a given color from color map0 by 8 bit RGB value and double alpha value. \n\
3215 \n\
3216 DESCRIPTION:\n\
3217 \n\
3218  Set a given color by 8-bit RGB value and double alpha value for color \n\
3219  map0 (see the PLplot documentation). Overwrites the previous color\n\
3220  value for the given index and, thus, does not result in any\n\
3221  additional allocation of space for colors. \n\
3222 \n\
3223  This function is used in example 30. \n\
3224 \n\
3225 \n\
3226 \n\
3227 SYNOPSIS:\n\
3228 \n\
3229 plscol0a(icol0, r, g, b, a)\n\
3230 \n\
3231 ARGUMENTS:\n\
3232 \n\
3233  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3234  number of colors (which is set by default, by plscmap0n, or even\n\
3235  by plscmap0). \n\
3236 \n\
3237  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3238  degree of red in the color. \n\
3239 \n\
3240  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3241  degree of green in the color. \n\
3242 \n\
3243  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3244  degree of blue in the color. \n\
3245 \n\
3246  a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
3247  value of the color. \n\
3248 ";
3249 const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3250 Set y axis parameters \n\
3251 \n\
3252 DESCRIPTION:\n\
3253 \n\
3254  Identical to plsxax, except that arguments are flags for y axis. See\n\
3255  the description of plsxax for more detail. \n\
3256 \n\
3257  Redacted form: plsyax(digmax, digits)\n\
3258 \n\
3259  This function is used in examples 1,14,31. \n\
3260 \n\
3261 \n\
3262 \n\
3263 SYNOPSIS:\n\
3264 \n\
3265 plsyax(digmax, digits)\n\
3266 \n\
3267 ARGUMENTS:\n\
3268 \n\
3269  digmax (PLINT, input) : Variable to set the maximum number of\n\
3270  digits for the y axis. If nonzero, the printed label will be\n\
3271  switched to a floating point representation when the number of\n\
3272  digits exceeds digmax. \n\
3273 \n\
3274  digits (PLINT, input) : Field digits value. Currently, changing\n\
3275  its value here has no effect since it is set only by plbox or\n\
3276  plbox3. However, the user may obtain its value after a call to\n\
3277  either of these functions by calling plgyax. \n\
3278 ";
3279 const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3280 Returns 8-bit RGB values for given color from color map0 \n\
3281 \n\
3282 DESCRIPTION:\n\
3283 \n\
3284  Returns 8-bit RGB values (0-255) for given color from color map0 (see\n\
3285  the PLplot documentation).\tValues are negative if an invalid color id\n\
3286  is given. \n\
3287 \n\
3288  Redacted form: plgcol0(icol0, r, g, b)\n\
3289 \n\
3290  This function is used in example 2. \n\
3291 \n\
3292 \n\
3293 \n\
3294 SYNOPSIS:\n\
3295 \n\
3296 plgcol0(icol0, r, g, b)\n\
3297 \n\
3298 ARGUMENTS:\n\
3299 \n\
3300  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3301 \n\
3302  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3303 \n\
3304  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3305 \n\
3306  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3307 ";
3308 const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3309 Set seed for internal random number generator. \n\
3310 \n\
3311 DESCRIPTION:\n\
3312 \n\
3313  Set the seed for the internal random number generator. See plrandd for\n\
3314  further details. \n\
3315 \n\
3316  Redacted form: plseed(seed)\n\
3317 \n\
3318  This function is used in example 21. \n\
3319 \n\
3320 \n\
3321 \n\
3322 SYNOPSIS:\n\
3323 \n\
3324 plseed(seed)\n\
3325 \n\
3326 ARGUMENTS:\n\
3327 \n\
3328  seed (unsigned int, input) : Seed for random number generator. \n\
3329 ";
3330 const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3331 Get output file name \n\
3332 \n\
3333 DESCRIPTION:\n\
3334 \n\
3335  Gets the current output file name, if applicable. \n\
3336 \n\
3337  Redacted form: plgfnam(fnam)\n\
3338 \n\
3339  This function is used in example 31. \n\
3340 \n\
3341 \n\
3342 \n\
3343 SYNOPSIS:\n\
3344 \n\
3345 plgfnam(fnam)\n\
3346 \n\
3347 ARGUMENTS:\n\
3348 \n\
3349  fnam (char *, output) : Pointer to file name string (a preallocated\n\
3350  string of 80 characters or more). \n\
3351 ";
3352 const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3353 Specify world coordinates of viewport boundaries \n\
3354 \n\
3355 DESCRIPTION:\n\
3356 \n\
3357  Sets up the world coordinates of the edges of the viewport. \n\
3358 \n\
3359  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3360 \n\
3361  This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3362 \n\
3363 \n\
3364 \n\
3365 SYNOPSIS:\n\
3366 \n\
3367 plwind(xmin, xmax, ymin, ymax)\n\
3368 \n\
3369 ARGUMENTS:\n\
3370 \n\
3371  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3372  of the viewport. \n\
3373 \n\
3374  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3375  of the viewport. \n\
3376 \n\
3377  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3378  the viewport. \n\
3379 \n\
3380  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3381  viewport. \n\
3382 ";
3383 const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3384 Set color map1 colors using a piece-wise linear relationship \n\
3385 \n\
3386 DESCRIPTION:\n\
3387 \n\
3388  Set color map1 colors using a piece-wise linear relationship between\n\
3389  position in the color map (from 0 to 1) and position in HLS or RGB\n\
3390  color space (see the PLplot documentation). May be called at any\n\
3391  time. \n\
3392 \n\
3393  The idea here is to specify a number of control points that define the\n\
3394  mapping between palette 1 input positions (intensities) and HLS (or\n\
3395  RGB). Between these points, linear interpolation is used which gives\n\
3396  a smooth variation of color with input position. Any number of\n\
3397  control points may be specified, located at arbitrary positions,\n\
3398  although typically 2 - 4 are enough. Another way of stating this is\n\
3399  that we are traversing a given number of lines through HLS (or RGB)\n\
3400  space as we move through color map1 entries. The control points at\n\
3401  the minimum and maximum position (0 and 1) must always be specified. \n\
3402  By adding more control points you can get more variation. One good\n\
3403  technique for plotting functions that vary about some expected average\n\
3404  is to use an additional 2 control points in the center (position ~=\n\
3405  0.5) that are the same lightness as the background (typically white\n\
3406  for paper output, black for crt), and same hue as the boundary control\n\
3407  points. This allows the highs and lows to be very easily\n\
3408  distinguished. \n\
3409 \n\
3410  Each control point must specify the position in color map1 as well as\n\
3411  three coordinates in HLS or RGB space. The first point must\n\
3412  correspond to position = 0, and the last to position = 1. \n\
3413 \n\
3414  The default behaviour is for the hue to be linearly interpolated \n\
3415  between the control points. Since the hue lies in the range [0, 360]\n\
3416  this corresponds to interpolation around the \"front\" of the color\n\
3417  wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3418  alternative interpolation is used between control points i and i+1. If\n\
3419  hue[i+1]-hue[i] > 0 then interpolation is between\thue[i] and\n\
3420  hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n\
3421  consider this as interpolation around the \"back\" or \"reverse\" of the\n\
3422  color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3423  alt_hue_path[] = false for\tevery control point. \n\
3424 \n\
3425  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3426  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3427  240]truegreen-yellow-red-magenta-blue[240\n\
3428  120]trueblue-magenta-red-yellow-green\n\
3429 \n\
3430  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3431  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3432  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3433 \n\
3434  Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n\
3435  alt_hue_path)\n\
3436 \n\
3437  This function is used in examples 8,11,12,15,20,21. \n\
3438 \n\
3439 \n\
3440 \n\
3441 SYNOPSIS:\n\
3442 \n\
3443 plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n\
3444 \n\
3445 ARGUMENTS:\n\
3446 \n\
3447  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3448 \n\
3449  npts (PLINT, input) : number of control points \n\
3450 \n\
3451  pos (PLFLT *, input) : position for each control point (between 0.0\n\
3452  and 1.0, in ascending order) \n\
3453 \n\
3454  coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
3455  control point \n\
3456 \n\
3457  coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
3458  control point \n\
3459 \n\
3460  coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
3461  control point \n\
3462 \n\
3463  alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
3464  flag for each control point. (alt_hue_path[i] refers to the\n\
3465  interpolation interval between the i and i + 1 control points). \n\
3466 ";
3467 const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3468 Set the pause (on end-of-page) status \n\
3469 \n\
3470 DESCRIPTION:\n\
3471 \n\
3472  Set the pause (on end-of-page) status. \n\
3473 \n\
3474  Redacted form: plspause(pause)\n\
3475 \n\
3476  This function is in examples 14,20. \n\
3477 \n\
3478 \n\
3479 \n\
3480 SYNOPSIS:\n\
3481 \n\
3482 plspause(pause)\n\
3483 \n\
3484 ARGUMENTS:\n\
3485 \n\
3486  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3487  end-of-page for those drivers which support this. Otherwise there\n\
3488  is no pause. \n\
3489 ";
3490 const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
3491 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3492 \n\
3493 DESCRIPTION:\n\
3494 \n\
3495  Routine for creating a discrete plot legend with a plotted filled box,\n\
3496  line, and/or line of symbols for each annotated legend entry. (See\n\
3497  plcolorbar for similar functionality for creating continuous color\n\
3498  bars.) The arguments of pllegend provide control over the location\n\
3499  and size of the legend as well as the location and characteristics of\n\
3500  the elements (most of which are optional) within that legend. The\n\
3501  resulting legend is clipped at the boundaries of the current subpage. \n\
3502  (N.B. the adopted coordinate system used for some of the parameters is\n\
3503  defined in the documentation of the position parameter.) \n\
3504 \n\
3505  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3506  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3507  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3508  test_justification, text_colors, text, box_colors, box_patterns,\n\
3509  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3510  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3511 \n\
3512  This function is used in examples 4, 26, and 33. \n\
3513 \n\
3514 \n\
3515 \n\
3516 SYNOPSIS:\n\
3517 \n\
3518 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\
3519 \n\
3520 ARGUMENTS:\n\
3521 \n\
3522  p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3523  contains (after the call) the legend width in adopted coordinates.\n\
3524  This quantity is calculated from plot_width, text_offset, ncolumn\n\
3525  (possibly modified inside the routine depending on nlegend and\n\
3526  nrow), and the length (calculated internally) of the longest text\n\
3527  string. \n\
3528 \n\
3529  p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3530  contains (after the call) the legend height in adopted\n\
3531  coordinates. This quantity is calculated from text_scale,\n\
3532  text_spacing, and nrow (possibly modified inside the routine\n\
3533  depending on nlegend and nrow). \n\
3534 \n\
3535  opt (PLINT, input) : opt contains bits controlling the overall\n\
3536  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3537  on the left of the legend and the plotted area on the right.\n\
3538  Otherwise, put the text area on the right of the legend and the\n\
3539  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3540  plot a (semi-transparent) background for the legend. If the\n\
3541  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3542  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3543  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3544  plot the resulting array of legend entries in row-major order.\n\
3545  Otherwise, plot the legend entries in column-major order. \n\
3546 \n\
3547  position (PLINT, input) : position contains bits which control the\n\
3548  overall position of the legend and the definition of the adopted\n\
3549  coordinates used for positions just like what is done for the\n\
3550  position argument for plcolorbar. However, note that the defaults\n\
3551  for the position bits (see below) are different than the\n\
3552  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3553  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3554  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3555  the 16 possible standard positions (the 4 corners and centers of\n\
3556  the 4 sides for both the inside and outside cases) of the legend\n\
3557  relative to the adopted coordinate system. The corner positions\n\
3558  are specified by the appropriate combination of two of the\n\
3559  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3560  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3561  value of one of those bits. The adopted coordinates are\n\
3562  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3563  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3564  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3565  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3566  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3567  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3568  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3569  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3570 \n\
3571  x (PLFLT, input) : X offset of the legend position in adopted\n\
3572  coordinates from the specified standard position of the legend.\n\
3573  For positive x, the direction of motion away from the standard\n\
3574  position is inward/outward from the standard corner positions or\n\
3575  standard left or right positions if the\n\
3576  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3577  For the standard top or bottom positions, the direction of motion\n\
3578  is toward positive X. \n\
3579 \n\
3580  y (PLFLT, input) : Y offset of the legend position in adopted\n\
3581  coordinates from the specified standard position of the legend.\n\
3582  For positive y, the direction of motion away from the standard\n\
3583  position is inward/outward from the standard corner positions or\n\
3584  standard top or bottom positions if the\n\
3585  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3586  For the standard left or right positions, the direction of motion\n\
3587  is toward positive Y. \n\
3588 \n\
3589  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3590  of the plot area (where the colored boxes, lines, and/or lines of\n\
3591  symbols are drawn) of the legend. \n\
3592 \n\
3593  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3594  legend (PL_LEGEND_BACKGROUND). \n\
3595 \n\
3596  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3597  for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3598 \n\
3599  bb_style (PLINT, input) : The pllsty style number for the\n\
3600  bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n\
3601 \n\
3602  nrow (PLINT, input) : The cmap0 index of the background color for\n\
3603  the legend (PL_LEGEND_BACKGROUND). \n\
3604 \n\
3605  ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3606  for the legend (PL_LEGEND_BACKGROUND). \n\
3607 \n\
3608  nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3609  vertical height of the legend in adopted coordinates is calculated\n\
3610  internally from nlegend, text_scale (see below), and text_spacing\n\
3611  (see below). \n\
3612 \n\
3613  opt_array (const PLINT *, input) : Array of nlegend values of\n\
3614  options to control each individual plotted area corresponding to a\n\
3615  legend entry. If the \n\
3616  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3617  area. If the \n\
3618  PL_LEGEND_COLOR_BOX, \n\
3619  PL_LEGEND_LINE, and/or \n\
3620  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3621  entry is plotted with a colored box; a line; and/or a line of\n\
3622  symbols. \n\
3623 \n\
3624  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3625  area in units of character width. N.B. The total horizontal\n\
3626  width of the legend in adopted coordinates is calculated\n\
3627  internally from \n\
3628  plot_width (see above), \n\
3629  text_offset, and length (calculated internally) of the longest text\n\
3630  string. \n\
3631 \n\
3632  text_scale (PLFLT, input) : Character height scale for text\n\
3633  annotations. N.B. The total vertical height of the legend in\n\
3634  adopted coordinates is calculated internally from \n\
3635  nlegend (see above), \n\
3636  text_scale, and \n\
3637  text_spacing (see below). \n\
3638 \n\
3639  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3640  character height from one legend entry to the next. N.B. The\n\
3641  total vertical height of the legend in adopted coordinates is\n\
3642  calculated internally from \n\
3643  nlegend (see above), \n\
3644  text_scale (see above), and \n\
3645  text_spacing. \n\
3646 \n\
3647  text_justification (PLFLT, input) : Justification parameter used\n\
3648  for text justification. The most common values of\n\
3649  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3650  is left justified, centred, or right justified within the text\n\
3651  area, but other values are allowed as well. \n\
3652 \n\
3653  text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n\
3654  colors. \n\
3655 \n\
3656  text (const char *const *, input) : Array of nlegend text string\n\
3657  annotations. \n\
3658 \n\
3659  box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n\
3660  for the discrete colored boxes (\n\
3661  PL_LEGEND_COLOR_BOX). \n\
3662 \n\
3663  box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3664  (plpsty indices) for the discrete colored boxes (\n\
3665  PL_LEGEND_COLOR_BOX). \n\
3666 \n\
3667  box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3668  of fraction of character height) for the height of the discrete\n\
3669  colored boxes (\n\
3670  PL_LEGEND_COLOR_BOX). \n\
3671 \n\
3672  box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3673  widths for the patterns specified by box_patterns (\n\
3674  PL_LEGEND_COLOR_BOX). \n\
3675 \n\
3676  line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n\
3677  colors (\n\
3678  PL_LEGEND_LINE). \n\
3679 \n\
3680  line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3681  (plsty indices) (\n\
3682  PL_LEGEND_LINE). \n\
3683 \n\
3684  line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3685  PL_LEGEND_LINE). \n\
3686 \n\
3687  symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n\
3688  symbol colors (\n\
3689  PL_LEGEND_SYMBOL). \n\
3690 \n\
3691  symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3692  values for the symbol height (\n\
3693  PL_LEGEND_SYMBOL). \n\
3694 \n\
3695  symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3696  symbols to be drawn across the width of the plotted area (\n\
3697  PL_LEGEND_SYMBOL). \n\
3698 \n\
3699  symbols (const char *const *, input) : Array of nlegend symbols\n\
3700  (plpoin indices) (\n\
3701  PL_LEGEND_SYMBOL). \n\
3702 ";
3703 const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
3704 Set number of colors in color map1 \n\
3705 \n\
3706 DESCRIPTION:\n\
3707 \n\
3708  Set number of colors in color map1, (re-)allocate color map1, and set\n\
3709  default values if this is the first allocation (see the PLplot\n\
3710  documentation). \n\
3711 \n\
3712  Redacted form: plscmap1n(ncol1)\n\
3713 \n\
3714  This function is used in examples 8,11,20,21. \n\
3715 \n\
3716 \n\
3717 \n\
3718 SYNOPSIS:\n\
3719 \n\
3720 plscmap1n(ncol1)\n\
3721 \n\
3722 ARGUMENTS:\n\
3723 \n\
3724  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3725  the map1 palette. If this number is zero or less, then the value\n\
3726  from the previous call to plscmap1n is used and if there is no\n\
3727  previous call, then a default value is used. \n\
3728 ";
3729 const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
3730 Returns 8-bit RGB values and double alpha value for given color from color map0. \n\
3731 \n\
3732 DESCRIPTION:\n\
3733 \n\
3734  Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n\
3735  for given color from color map0 (see the PLplot documentation). \n\
3736  Values are negative if an invalid color id is given. \n\
3737 \n\
3738  This function is used in example 30. \n\
3739 \n\
3740 \n\
3741 \n\
3742 SYNOPSIS:\n\
3743 \n\
3744 plgcol0a(icol0, r, g, b, a)\n\
3745 \n\
3746 ARGUMENTS:\n\
3747 \n\
3748  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3749 \n\
3750  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3751 \n\
3752  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3753 \n\
3754  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3755 \n\
3756  a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
3757 ";
3758 const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
3759 Replays contents of plot buffer to current device/file \n\
3760 \n\
3761 DESCRIPTION:\n\
3762 \n\
3763  Replays contents of plot buffer to current device/file. \n\
3764 \n\
3765  Redacted form: plreplot()\n\
3766 \n\
3767  This function is used in example 1,20. \n\
3768 \n\
3769 \n\
3770 \n\
3771 SYNOPSIS:\n\
3772 \n\
3773 plreplot()\n\
3774 ";
3775 const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
3776 Simple routine to write labels \n\
3777 \n\
3778 DESCRIPTION:\n\
3779 \n\
3780  Routine for writing simple labels. Use plmtex for more complex labels. \n\
3781 \n\
3782  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3783 \n\
3784  This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3785 \n\
3786 \n\
3787 \n\
3788 SYNOPSIS:\n\
3789 \n\
3790 pllab(xlabel, ylabel, tlabel)\n\
3791 \n\
3792 ARGUMENTS:\n\
3793 \n\
3794  xlabel (const char *, input) : Label for horizontal axis. \n\
3795 \n\
3796  ylabel (const char *, input) : Label for vertical axis. \n\
3797 \n\
3798  tlabel (const char *, input) : Title of graph. \n\
3799 ";
3800 const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
3801 Set parameters that define current device-space window \n\
3802 \n\
3803 DESCRIPTION:\n\
3804 \n\
3805  Set relative margin width, aspect ratio, and relative justification\n\
3806  that define current device-space window. If you want to just use the\n\
3807  previous value for any of these, just pass in the magic value\n\
3808  PL_NOTSET. It is unlikely that one should ever need to change the\n\
3809  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3810  called the default values of mar, jx, and jy are all 0. aspect is set\n\
3811  to a device-specific value. \n\
3812 \n\
3813  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3814 \n\
3815  This function is used in example 31. \n\
3816 \n\
3817 \n\
3818 \n\
3819 SYNOPSIS:\n\
3820 \n\
3821 plsdidev(mar, aspect, jx, jy)\n\
3822 \n\
3823 ARGUMENTS:\n\
3824 \n\
3825  mar (PLFLT, input) : Relative margin width. \n\
3826 \n\
3827  aspect (PLFLT, input) : Aspect ratio. \n\
3828 \n\
3829  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3830  the range -0.5 to 0.5. \n\
3831 \n\
3832  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3833  the range -0.5 to 0.5. \n\
3834 ";
3835 const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
3836 Begin a new page\n\
3837 \n\
3838 DESCRIPTION:\n\
3839 \n\
3840  Begins a new page.\tFor a file driver, the output file is opened if\n\
3841  necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3842  page break is desired at a particular point when plotting to subpages.\n\
3843  Another use for pleop and plbop is when plotting pages to different\n\
3844  files, since you can manually set the file name by calling plsfnam\n\
3845  after the call to pleop. (In fact some drivers may only support a\n\
3846  single page per file, making this a necessity.) One way to handle\n\
3847  this case automatically is to page advance via pladv, but enable\n\
3848  familying (see plsfam) with a small limit on the file size so that a\n\
3849  new family member file will be created on each page break. \n\
3850 \n\
3851  Redacted form: plbop()\n\
3852 \n\
3853  This function is used in examples 2,20. \n\
3854 \n\
3855 \n\
3856 \n\
3857 SYNOPSIS:\n\
3858 \n\
3859 plbop()\n\
3860 ";
3861 const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
3862 Set color map0 colors by 8-bit RGB values \n\
3863 \n\
3864 DESCRIPTION:\n\
3865 \n\
3866  Set color map0 colors using 8-bit RGB values (see the PLplot\n\
3867  documentation). This sets the entire color map -- only as many colors\n\
3868  as specified will be allocated. \n\
3869 \n\
3870  Redacted form: plscmap0(r, g, b, ncol0)\n\
3871 \n\
3872  This function is used in examples 2,24. \n\
3873 \n\
3874 \n\
3875 \n\
3876 SYNOPSIS:\n\
3877 \n\
3878 plscmap0(r, g, b, ncol0)\n\
3879 \n\
3880 ARGUMENTS:\n\
3881 \n\
3882  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3883  integers (0-255) representing the degree of red in the color. \n\
3884 \n\
3885  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3886  integers (0-255) representing the degree of green in the color. \n\
3887 \n\
3888  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3889  integers (0-255) representing the degree of blue in the color. \n\
3890 \n\
3891  ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3892 ";
3893 const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
3894 Set the number of subpages in x and y \n\
3895 \n\
3896 DESCRIPTION:\n\
3897 \n\
3898  Set the number of subpages in x and y. \n\
3899 \n\
3900  Redacted form: plssub(nx, ny)\n\
3901 \n\
3902  This function is examples 1,2,14,21,25,27. \n\
3903 \n\
3904 \n\
3905 \n\
3906 SYNOPSIS:\n\
3907 \n\
3908 plssub(nx, ny)\n\
3909 \n\
3910 ARGUMENTS:\n\
3911 \n\
3912  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
3913  of window columns). \n\
3914 \n\
3915  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
3916  of window rows). \n\
3917 ";
3918 const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
3919 Set a global coordinate transform function \n\
3920 \n\
3921 DESCRIPTION:\n\
3922 \n\
3923  This function can be used to define a coordinate transformation which\n\
3924  affects all elements drawn within the current plot window.\tThe\n\
3925  transformation function is similar to that provided for the plmap and\n\
3926  plmeridians functions. The data parameter may be used to pass extra\n\
3927  data to transform_fun. \n\
3928 \n\
3929  Redacted form: General: plstransform(transform_fun, data)\n\
3930 \n\
3931 \n\
3932  This function is used in examples 19 and 22. \n\
3933 \n\
3934 \n\
3935 \n\
3936 SYNOPSIS:\n\
3937 \n\
3938 plstransform(transform_fun, data)\n\
3939 \n\
3940 ARGUMENTS:\n\
3941 \n\
3942  transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n\
3943  input) : Pointer to a function that defines a transformation\n\
3944  from the input (x, y) coordinate to a new plot world coordinate. A\n\
3945  NULL pointer means that no transform is applied. \n\
3946 \n\
3947  data (PLPointer, input) : Optional extra data for \n\
3948  transform_fun. \n\
3949 ";
3950 const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
3951 Set color map1 colors using 8-bit RGB values \n\
3952 \n\
3953 DESCRIPTION:\n\
3954 \n\
3955  Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3956  documentation). This also sets the number of colors. \n\
3957 \n\
3958  Redacted form: plscmap1(r, g, b, ncol1)\n\
3959 \n\
3960  This function is used in example 31. \n\
3961 \n\
3962 \n\
3963 \n\
3964 SYNOPSIS:\n\
3965 \n\
3966 plscmap1(r, g, b, ncol1)\n\
3967 \n\
3968 ARGUMENTS:\n\
3969 \n\
3970  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3971  integers (0-255) representing the degree of red in the color. \n\
3972 \n\
3973  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3974  integers (0-255) representing the degree of green in the color. \n\
3975 \n\
3976  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3977  integers (0-255) representing the degree of blue in the color. \n\
3978 \n\
3979  ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3980 ";
3981 const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
3982 Set length of minor ticks \n\
3983 \n\
3984 DESCRIPTION:\n\
3985 \n\
3986  This sets up the length of the minor ticks and the length of the\n\
3987  terminals on error bars. The actual length is the product of the\n\
3988  default length and a scaling factor as for character height. \n\
3989 \n\
3990  Redacted form: plsmin(def, scale)\n\
3991 \n\
3992  This function is used in example 29. \n\
3993 \n\
3994 \n\
3995 \n\
3996 SYNOPSIS:\n\
3997 \n\
3998 plsmin(def, scale)\n\
3999 \n\
4000 ARGUMENTS:\n\
4001 \n\
4002  def (PLFLT, input) : The default length of a minor tick in\n\
4003  millimeters, should be set to zero if the default length is to\n\
4004  remain unchanged. \n\
4005 \n\
4006  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4007  actual tick length. \n\
4008 ";
4009 const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4010 Set character size \n\
4011 \n\
4012 DESCRIPTION:\n\
4013 \n\
4014  This sets up the size of all subsequent characters drawn. The actual\n\
4015  height of a character is the product of the default character size and\n\
4016  a scaling factor. \n\
4017 \n\
4018  Redacted form: plschr(def, scale)\n\
4019 \n\
4020  This function is used in example 2,13,23,24. \n\
4021 \n\
4022 \n\
4023 \n\
4024 SYNOPSIS:\n\
4025 \n\
4026 plschr(def, scale)\n\
4027 \n\
4028 ARGUMENTS:\n\
4029 \n\
4030  def (PLFLT, input) : The default height of a character in\n\
4031  millimeters, should be set to zero if the default height is to\n\
4032  remain unchanged. \n\
4033 \n\
4034  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4035  actual character height. \n\
4036 ";
4037 const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4038 Initialize PLplot \n\
4039 \n\
4040 DESCRIPTION:\n\
4041 \n\
4042  Initializing the plotting package.\tThe program prompts for the device\n\
4043  keyword or number of the desired output device. Hitting a RETURN in\n\
4044  response to the prompt is the same as selecting the first device. \n\
4045  plinit will issue no prompt if either the device was specified\n\
4046  previously (via command line flag, the plsetopt function, or the\n\
4047  plsdev function), or if only one device is enabled when PLplot is\n\
4048  installed.\tIf subpages have been specified, the output device is\n\
4049  divided into nx by ny subpages, each of which may be used\n\
4050  independently. If plinit is called again during a program, the\n\
4051  previously opened file will be closed. The subroutine pladv is used\n\
4052  to advance from one subpage to the next. \n\
4053 \n\
4054  Redacted form: plinit()\n\
4055 \n\
4056  This function is used in all of the examples. \n\
4057 \n\
4058 \n\
4059 \n\
4060 SYNOPSIS:\n\
4061 \n\
4062 plinit()\n\
4063 ";
4064 const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4065 Draw a box with axes, etc\n\
4066 \n\
4067 DESCRIPTION:\n\
4068 \n\
4069  Draws a box around the currently defined viewport, and labels it with\n\
4070  world coordinate values appropriate to the window.\tThus plbox should\n\
4071  only be called after defining both viewport and window. The character\n\
4072  strings xopt and yopt specify how the box should be drawn as described\n\
4073  below. If ticks and/or subticks are to be drawn for a particular\n\
4074  axis, the tick intervals and number of subintervals may be specified\n\
4075  explicitly, or they may be defaulted by setting the appropriate\n\
4076  arguments to zero. \n\
4077 \n\
4078  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4079 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4080 \n\
4081 \n\
4082  This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4083 \n\
4084 \n\
4085 \n\
4086 SYNOPSIS:\n\
4087 \n\
4088 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4089 \n\
4090 ARGUMENTS:\n\
4091 \n\
4092  xopt (const char *, input) : Pointer to character string specifying\n\
4093  options for horizontal axis. The string can include any\n\
4094  combination of the following letters (upper or lower case) in any\n\
4095  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4096  is vertical line (x=0). \n\
4097  b: Draws bottom (X) or left (Y) edge of frame. \n\
4098  c: Draws top (X) or right (Y) edge of frame. \n\
4099  d: Plot labels as date / time. Values are assumed to be\n\
4100  seconds since the epoch (as used by gmtime). \n\
4101  f: Always use fixed point numeric labels. \n\
4102  g: Draws a grid at the major tick interval. \n\
4103  h: Draws a grid at the minor tick interval. \n\
4104  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4105  inwards. \n\
4106  l: Labels axis logarithmically. This only affects the labels,\n\
4107  not the data, and so it is necessary to compute the logarithms\n\
4108  of data points before passing them to any of the drawing\n\
4109  routines. \n\
4110  m: Writes numeric labels at major tick intervals in the\n\
4111  unconventional location (above box for X, right of box for Y). \n\
4112  n: Writes numeric labels at major tick intervals in the\n\
4113  conventional location (below box for X, left of box for Y). \n\
4114  o: Use custom labelling function to generate axis label text. \n\
4115  The custom labelling function can be defined with the\n\
4116  plslabelfunc command. \n\
4117  s: Enables subticks between major ticks, only valid if t is\n\
4118  also specified. \n\
4119  t: Draws major ticks. \n\
4120  u: Exactly like \"b\" except don\'t draw edge line. \n\
4121  w: Exactly like \"c\" except don\'t draw edge line. \n\
4122  x: Exactly like \"t\" (including the side effect of the\n\
4123  numerical labels for the major ticks) except exclude drawing\n\
4124  the major and minor tick marks. \n\
4125 \n\
4126 \n\
4127  xtick (PLFLT, input) : World coordinate interval between major\n\
4128  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4129  generates a suitable tick interval. \n\
4130 \n\
4131  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4132  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4133  generates a suitable minor tick interval. \n\
4134 \n\
4135  yopt (const char *, input) : Pointer to character string specifying\n\
4136  options for vertical axis. The string can include any combination\n\
4137  of the letters defined above for xopt, and in addition may\n\
4138  contain: v: Write numeric labels for vertical axis parallel to the\n\
4139  base of the graph, rather than parallel to the axis. \n\
4140 \n\
4141 \n\
4142  ytick (PLFLT, input) : World coordinate interval between major\n\
4143  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4144  generates a suitable tick interval. \n\
4145 \n\
4146  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4147  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4148  generates a suitable minor tick interval. \n\
4149 ";
4150 const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4151 Get parameters that define current device-space window \n\
4152 \n\
4153 DESCRIPTION:\n\
4154 \n\
4155  Get relative margin width, aspect ratio, and relative justification\n\
4156  that define current device-space window. If plsdidev has not been\n\
4157  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4158  p_jy will all be 0. \n\
4159 \n\
4160  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4161 \n\
4162  This function is used in example 31. \n\
4163 \n\
4164 \n\
4165 \n\
4166 SYNOPSIS:\n\
4167 \n\
4168 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4169 \n\
4170 ARGUMENTS:\n\
4171 \n\
4172  p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4173 \n\
4174  p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4175 \n\
4176  p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4177 \n\
4178  p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4179 ";
4180 const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4181 Plot a glyph at the specified points \n\
4182 \n\
4183 DESCRIPTION:\n\
4184 \n\
4185  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4186  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4187  is specified with a PLplot user string. Note that the user string is\n\
4188  not actually limited to one glyph so it is possible (but not normally\n\
4189  useful) to plot more than one glyph at the specified points with this\n\
4190  function. As with plmtex and plptex, the user string can contain FCI\n\
4191  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4192  else PLplot escapes for Hershey or unicode text to determine the\n\
4193  glyph. \n\
4194 \n\
4195  Redacted form: plstring(x, y, string)\n\
4196 \n\
4197  This function is used in examples 4, 21 and 26. \n\
4198 \n\
4199 \n\
4200 \n\
4201 SYNOPSIS:\n\
4202 \n\
4203 plstring(n, x, y, string)\n\
4204 \n\
4205 ARGUMENTS:\n\
4206 \n\
4207  n (PLINT, input) : Number of points in the x and y arrays. \n\
4208 \n\
4209  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
4210  points. \n\
4211 \n\
4212  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
4213  points. \n\
4214 \n\
4215  string (const char *, input) : PLplot user string corresponding to\n\
4216  the glyph to be plotted at each of the n points. \n\
4217 ";
4218 const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4219 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n\
4220 \n\
4221 DESCRIPTION:\n\
4222 \n\
4223  Sets up plotter environment for simple graphs by calling pladv and\n\
4224  setting up viewport and window to sensible default values.\tplenv0\n\
4225  leaves enough room around most graphs for axis labels and a title.\n\
4226  When these defaults are not suitable, use the individual routines\n\
4227  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4228  defining the window, and plbox for drawing the box. \n\
4229 \n\
4230  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4231 \n\
4232  This function is used in example 21. \n\
4233 \n\
4234 \n\
4235 \n\
4236 SYNOPSIS:\n\
4237 \n\
4238 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4239 \n\
4240 ARGUMENTS:\n\
4241 \n\
4242  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4243  world coordinates). \n\
4244 \n\
4245  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4246  world coordinates). \n\
4247 \n\
4248  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4249  coordinates). \n\
4250 \n\
4251  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4252  coordinates). \n\
4253 \n\
4254  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4255  scales will not be set, the user must set up the scale before\n\
4256  calling plenv0 using plsvpa, plvasp or other. \n\
4257  0: the x and y axes are scaled independently to use as much of\n\
4258  the screen as possible. \n\
4259  1: the scales of the x and y axes are made equal. \n\
4260  2: the axis of the x and y axes are made equal, and the plot\n\
4261  box will be square. \n\
4262 \n\
4263 \n\
4264  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4265  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4266  -1: draw box only. \n\
4267  0: draw box, ticks, and numeric tick labels. \n\
4268  1: also draw coordinate axes at x=0 and y=0. \n\
4269  2: also draw a grid at major tick positions in both\n\
4270  coordinates. \n\
4271  3: also draw a grid at minor tick positions in both\n\
4272  coordinates. \n\
4273  10: same as 0 except logarithmic x tick marks. (The x data\n\
4274  have to be converted to logarithms separately.) \n\
4275  11: same as 1 except logarithmic x tick marks. (The x data\n\
4276  have to be converted to logarithms separately.) \n\
4277  12: same as 2 except logarithmic x tick marks. (The x data\n\
4278  have to be converted to logarithms separately.) \n\
4279  13: same as 3 except logarithmic x tick marks. (The x data\n\
4280  have to be converted to logarithms separately.) \n\
4281  20: same as 0 except logarithmic y tick marks. (The y data\n\
4282  have to be converted to logarithms separately.) \n\
4283  21: same as 1 except logarithmic y tick marks. (The y data\n\
4284  have to be converted to logarithms separately.) \n\
4285  22: same as 2 except logarithmic y tick marks. (The y data\n\
4286  have to be converted to logarithms separately.) \n\
4287  23: same as 3 except logarithmic y tick marks. (The y data\n\
4288  have to be converted to logarithms separately.) \n\
4289  30: same as 0 except logarithmic x and y tick marks. (The x\n\
4290  and y data have to be converted to logarithms separately.) \n\
4291  31: same as 1 except logarithmic x and y tick marks. (The x\n\
4292  and y data have to be converted to logarithms separately.) \n\
4293  32: same as 2 except logarithmic x and y tick marks. (The x\n\
4294  and y data have to be converted to logarithms separately.) \n\
4295  33: same as 3 except logarithmic x and y tick marks. (The x\n\
4296  and y data have to be converted to logarithms separately.) \n\
4297  40: same as 0 except date / time x labels. \n\
4298  41: same as 1 except date / time x labels. \n\
4299  42: same as 2 except date / time x labels. \n\
4300  43: same as 3 except date / time x labels. \n\
4301  50: same as 0 except date / time y labels. \n\
4302  51: same as 1 except date / time y labels. \n\
4303  52: same as 2 except date / time y labels. \n\
4304  53: same as 3 except date / time y labels. \n\
4305  60: same as 0 except date / time x and y labels. \n\
4306  61: same as 1 except date / time x and y labels. \n\
4307  62: same as 2 except date / time x and y labels. \n\
4308  63: same as 3 except date / time x and y labels. \n\
4309  70: same as 0 except custom x and y labels. \n\
4310  71: same as 1 except custom x and y labels. \n\
4311  72: same as 2 except custom x and y labels. \n\
4312  73: same as 3 except custom x and y labels. \n\
4313 ";
4314 const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
4315 Set up window for 3-d plotting \n\
4316 \n\
4317 DESCRIPTION:\n\
4318 \n\
4319  Sets up a window for a three-dimensional surface plot within the\n\
4320  currently defined two-dimensional window. The enclosing box for the\n\
4321  surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4322  user-coordinate space is mapped into a box of world coordinate size\n\
4323  basex by basey by height so that xmin maps to -\n\
4324  basex/2, xmax maps to basex/2, ymin maps to -\n\
4325  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4326  The resulting world-coordinate box is then viewed by an observer at\n\
4327  altitude alt and azimuth az. This routine must be called before\n\
4328  plbox3 or plot3d. For a more complete description of\n\
4329  three-dimensional plotting see the PLplot documentation. \n\
4330 \n\
4331  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4332  zmin, zmax, alt, az)\n\
4333 \n\
4334  This function is examples 8,11,18,21. \n\
4335 \n\
4336 \n\
4337 \n\
4338 SYNOPSIS:\n\
4339 \n\
4340 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4341 \n\
4342 ARGUMENTS:\n\
4343 \n\
4344  basex (PLFLT, input) : The x coordinate size of the\n\
4345  world-coordinate box. \n\
4346 \n\
4347  basey (PLFLT, input) : The y coordinate size of the\n\
4348  world-coordinate box. \n\
4349 \n\
4350  height (PLFLT, input) : The z coordinate size of the\n\
4351  world-coordinate box. \n\
4352 \n\
4353  xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4354 \n\
4355  xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4356 \n\
4357  ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4358 \n\
4359  ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4360 \n\
4361  zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4362 \n\
4363  zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4364 \n\
4365  alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4366  plane. \n\
4367 \n\
4368  az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n\
4369  observer is looking face onto the ZX plane, and as az is\n\
4370  increased, the observer moves clockwise around the box when viewed\n\
4371  from above the XY plane. \n\
4372 ";
4373 const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4374 Draw filled polygon \n\
4375 \n\
4376 DESCRIPTION:\n\
4377 \n\
4378  Fills the polygon defined by the n points (\n\
4379  x[i], \n\
4380  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4381  style is a solid fill. The routine will automatically close the\n\
4382  polygon between the last and first vertices. If multiple closed\n\
4383  polygons are passed in x and y then plfill will fill in between them. \n\
4384 \n\
4385  Redacted form: plfill(x,y)\n\
4386 \n\
4387  This function is used in examples 12,13,15,16,21,24,25. \n\
4388 \n\
4389 \n\
4390 \n\
4391 SYNOPSIS:\n\
4392 \n\
4393 plfill(n, x, y)\n\
4394 \n\
4395 ARGUMENTS:\n\
4396 \n\
4397  n (PLINT, input) : Number of vertices in polygon. \n\
4398 \n\
4399  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4400  vertices. \n\
4401 \n\
4402  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4403  vertices. \n\
4404 ";
4405 const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
4406 Write text relative to viewport boundaries \n\
4407 \n\
4408 DESCRIPTION:\n\
4409 \n\
4410  Writes text at a specified position relative to the viewport\n\
4411  boundaries. Text may be written inside or outside the viewport, but\n\
4412  is clipped at the subpage boundaries. The reference point of a string\n\
4413  lies along a line passing through the string at half the height of a\n\
4414  capital letter. The position of the reference point along this line\n\
4415  is determined by just, and the position of the reference point\n\
4416  relative to the viewport is set by disp and pos. \n\
4417 \n\
4418  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4419 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4420 \n\
4421 \n\
4422  This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4423 \n\
4424 \n\
4425 \n\
4426 SYNOPSIS:\n\
4427 \n\
4428 plmtex(side, disp, pos, just, text)\n\
4429 \n\
4430 ARGUMENTS:\n\
4431 \n\
4432  side (const char *, input) : Specifies the side of the viewport\n\
4433  along which the text is to be written. The string must be one of:\n\
4434  b: Bottom of viewport, text written parallel to edge. \n\
4435  bv: Bottom of viewport, text written at right angles to edge. \n\
4436  l: Left of viewport, text written parallel to edge. \n\
4437  lv: Left of viewport, text written at right angles to edge. \n\
4438  r: Right of viewport, text written parallel to edge. \n\
4439  rv: Right of viewport, text written at right angles to edge. \n\
4440  t: Top of viewport, text written parallel to edge. \n\
4441  tv: Top of viewport, text written at right angles to edge. \n\
4442 \n\
4443 \n\
4444  disp (PLFLT, input) : Position of the reference point of string,\n\
4445  measured outwards from the specified viewport edge in units of the\n\
4446  current character height. Use negative disp to write within the\n\
4447  viewport. \n\
4448 \n\
4449  pos (PLFLT, input) : Position of the reference point of string\n\
4450  along the specified edge, expressed as a fraction of the length of\n\
4451  the edge. \n\
4452 \n\
4453  just (PLFLT, input) : Specifies the position of the string relative\n\
4454  to its reference point. If just=0., the reference point is at the\n\
4455  left and if just=1., it is at the right of the string. Other\n\
4456  values of just give intermediate justifications. \n\
4457 \n\
4458  text (const char *, input) : The string to be written out. \n\
4459 ";
4460 const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4461 Set arrow style for vector plots \n\
4462 \n\
4463 DESCRIPTION:\n\
4464 \n\
4465  Set the style for the arrow used by plvect to plot vectors. \n\
4466 \n\
4467  Redacted form: plsvect(arrowx, arrowy, fill)\n\
4468 \n\
4469  This function is used in example 22. \n\
4470 \n\
4471 \n\
4472 \n\
4473 SYNOPSIS:\n\
4474 \n\
4475 plsvect(arrowx, arrowy, npts, fill)\n\
4476 \n\
4477 ARGUMENTS:\n\
4478 \n\
4479  arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n\
4480  containing the x and y points which make up the arrow. The arrow\n\
4481  is plotted by joining these points to form a polygon. The scaling\n\
4482  assumes that the x and y points in the arrow lie in the range -0.5\n\
4483  <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n\
4484  style will be reset to its default. \n\
4485 \n\
4486  npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4487  arrowy. \n\
4488 \n\
4489  fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4490  fill is false then the arrow is open. \n\
4491 ";
4492 const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
4493 Get family file parameters \n\
4494 \n\
4495 DESCRIPTION:\n\
4496 \n\
4497  Gets information about current family file, if familying is enabled. \n\
4498  See the PLplot documentation for more information. \n\
4499 \n\
4500  Redacted form: plgfam(fam, num, bmax)\n\
4501 \n\
4502  This function is used in examples 14,31. \n\
4503 \n\
4504 \n\
4505 \n\
4506 SYNOPSIS:\n\
4507 \n\
4508 plgfam(fam, num, bmax)\n\
4509 \n\
4510 ARGUMENTS:\n\
4511 \n\
4512  fam (PLINT *, output) : Pointer to variable with the Boolean family\n\
4513  flag value. If nonzero, familying is enabled. \n\
4514 \n\
4515  num (PLINT *, output) : Pointer to variable with the current family\n\
4516  file number. \n\
4517 \n\
4518  bmax (PLINT *, output) : Pointer to variable with the maximum file\n\
4519  size (in bytes) for a family file. \n\
4520 ";
4521 const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
4522 Random number generator returning a real random number in the range [0,1]. \n\
4523 \n\
4524 DESCRIPTION:\n\
4525 \n\
4526  Random number generator returning a real random number in the range\n\
4527  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4528  / compilers provide their own random number generator, and so this is\n\
4529  provided purely for convenience and to give a consistent random number\n\
4530  generator across all languages supported by PLplot. This is\n\
4531  particularly useful for comparing results from the test suite of\n\
4532  examples. \n\
4533 \n\
4534  Redacted form: plrandd()\n\
4535 \n\
4536  This function is used in examples 17,21. \n\
4537 \n\
4538 \n\
4539 \n\
4540 SYNOPSIS:\n\
4541 \n\
4542 plrandd()\n\
4543 ";
4544 const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
4545 Set line style \n\
4546 \n\
4547 DESCRIPTION:\n\
4548 \n\
4549  This sets up the line style for all lines subsequently drawn. A line\n\
4550  consists of segments in which the pen is alternately down and up. The\n\
4551  lengths of these segments are passed in the arrays mark and space\n\
4552  respectively. The number of mark-space pairs is specified by nels. \n\
4553  In order to return the line style to the default continuous line,\n\
4554  plstyl should be called with nels=0.(see also pllsty) \n\
4555 \n\
4556  Redacted form: plstyl(mark, space)\n\
4557 \n\
4558  This function is used in examples 1,9,14. \n\
4559 \n\
4560 \n\
4561 \n\
4562 SYNOPSIS:\n\
4563 \n\
4564 plstyl(nels, mark, space)\n\
4565 \n\
4566 ARGUMENTS:\n\
4567 \n\
4568  nels (PLINT, input) : The number of mark and space elements in a\n\
4569  line. Thus a simple broken line can be obtained by setting\n\
4570  nels=1. A continuous line is specified by setting nels=0. \n\
4571 \n\
4572  mark (PLINT *, input) : Pointer to array with the lengths of the\n\
4573  segments during which the pen is down, measured in micrometers. \n\
4574 \n\
4575  space (PLINT *, input) : Pointer to array with the lengths of the\n\
4576  segments during which the pen is up, measured in micrometers. \n\
4577 ";
4578 const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
4579 Set the colors for color table 0 from a cmap0 file \n\
4580 \n\
4581 DESCRIPTION:\n\
4582 \n\
4583  Set the colors for color table 0 from a cmap0 file \n\
4584 \n\
4585  Redacted form: plspal0(filename)\n\
4586 \n\
4587  This function is in example 16. \n\
4588 \n\
4589 \n\
4590 \n\
4591 SYNOPSIS:\n\
4592 \n\
4593 plspal0(filename)\n\
4594 \n\
4595 ARGUMENTS:\n\
4596 \n\
4597  filename (const char *, input) : The name of the cmap0 file, or a\n\
4598  empty to string to specify the default cmap0 file. \n\
4599 ";
4600 const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
4601 Set the colors for color table 1 from a cmap1 file \n\
4602 \n\
4603 DESCRIPTION:\n\
4604 \n\
4605  Set the colors for color table 1 from a cmap1 file \n\
4606 \n\
4607  Redacted form: plspal1(filename)\n\
4608 \n\
4609  This function is in example 16. \n\
4610 \n\
4611 \n\
4612 \n\
4613 SYNOPSIS:\n\
4614 \n\
4615 plspal1(filename)\n\
4616 \n\
4617 ARGUMENTS:\n\
4618 \n\
4619  filename (const char *, input) : The name of the cmap1 file, or a\n\
4620  empty to string to specify the default cmap1 file. \n\
4621 ";
4622 const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
4623 Set current output stream \n\
4624 \n\
4625 DESCRIPTION:\n\
4626 \n\
4627  Sets the number of the current output stream. The stream number\n\
4628  defaults to 0 unless changed by this routine. The first use of this\n\
4629  routine must be followed by a call initializing PLplot (e.g. plstar). \n\
4630 \n\
4631  Redacted form: plsstrm(strm)\n\
4632 \n\
4633  This function is examples 1,14,20. \n\
4634 \n\
4635 \n\
4636 \n\
4637 SYNOPSIS:\n\
4638 \n\
4639 plsstrm(strm)\n\
4640 \n\
4641 ARGUMENTS:\n\
4642 \n\
4643  strm (PLINT, input) : The current stream number. \n\
4644 ";
4645 const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4646 Specify viewport using coordinates \n\
4647 \n\
4648 DESCRIPTION:\n\
4649 \n\
4650  Device-independent routine for setting up the viewport. This defines\n\
4651  the viewport in terms of normalized subpage coordinates which run from\n\
4652  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4653  current subpage. Use the alternate routine plsvpa in order to create\n\
4654  a viewport of a definite size. \n\
4655 \n\
4656  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4657 \n\
4658  This function is used in examples\n\
4659  2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
4660 \n\
4661 \n\
4662 \n\
4663 SYNOPSIS:\n\
4664 \n\
4665 plvpor(xmin, xmax, ymin, ymax)\n\
4666 \n\
4667 ARGUMENTS:\n\
4668 \n\
4669  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4670  left-hand edge of the viewport. \n\
4671 \n\
4672  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4673  right-hand edge of the viewport. \n\
4674 \n\
4675  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4676  bottom edge of the viewport. \n\
4677 \n\
4678  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4679  edge of the viewport. \n\
4680 ";
4681 const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
4682 Write text inside the viewport \n\
4683 \n\
4684 DESCRIPTION:\n\
4685 \n\
4686  Writes text at a specified position and inclination within the\n\
4687  viewport. Text is clipped at the viewport boundaries. The reference\n\
4688  point of a string lies along a line passing through the string at half\n\
4689  the height of a capital letter. The position of the reference point\n\
4690  along this line is determined by just, the reference point is placed\n\
4691  at world coordinates (\n\
4692  x, \n\
4693  y) within the viewport. The inclination of the string is specified in\n\
4694  terms of differences of world coordinates making it easy to write text\n\
4695  parallel to a line in a graph. \n\
4696 \n\
4697  Redacted form: plptex(x, y, dx, dy, just, text)\n\
4698 \n\
4699  This function is used in example 2-4,10,12-14,20,23,24,26. \n\
4700 \n\
4701 \n\
4702 \n\
4703 SYNOPSIS:\n\
4704 \n\
4705 plptex(x, y, dx, dy, just, text)\n\
4706 \n\
4707 ARGUMENTS:\n\
4708 \n\
4709  x (PLFLT, input) : x coordinate of reference point of string. \n\
4710 \n\
4711  y (PLFLT, input) : y coordinate of reference point of string. \n\
4712 \n\
4713  dx (PLFLT, input) : Together with dy, this specifies the\n\
4714  inclination of the string. The baseline of the string is parallel\n\
4715  to a line joining (\n\
4716  x, \n\
4717  y) to (\n\
4718  x+\n\
4719  dx, \n\
4720  y+\n\
4721  dy). \n\
4722 \n\
4723  dy (PLFLT, input) : Together with dx, this specifies the\n\
4724  inclination of the string. \n\
4725 \n\
4726  just (PLFLT, input) : Specifies the position of the string relative\n\
4727  to its reference point. If just=0., the reference point is at the\n\
4728  left and if just=1., it is at the right of the string. Other\n\
4729  values of just give intermediate justifications. \n\
4730 \n\
4731  text (const char *, input) : The string to be written out. \n\
4732 ";
4733 const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
4734 Set z axis parameters \n\
4735 \n\
4736 DESCRIPTION:\n\
4737 \n\
4738  Identical to plsxax, except that arguments are flags for z axis. See\n\
4739  the description of plsxax for more detail. \n\
4740 \n\
4741  Redacted form: plszax(digmax, digits)\n\
4742 \n\
4743  This function is used in example 31. \n\
4744 \n\
4745 \n\
4746 \n\
4747 SYNOPSIS:\n\
4748 \n\
4749 plszax(digmax, digits)\n\
4750 \n\
4751 ARGUMENTS:\n\
4752 \n\
4753  digmax (PLINT, input) : Variable to set the maximum number of\n\
4754  digits for the z axis. If nonzero, the printed label will be\n\
4755  switched to a floating point representation when the number of\n\
4756  digits exceeds digmax. \n\
4757 \n\
4758  digits (PLINT, input) : Field digits value. Currently, changing\n\
4759  its value here has no effect since it is set only by plbox or\n\
4760  plbox3. However, the user may obtain its value after a call to\n\
4761  either of these functions by calling plgzax. \n\
4762 ";
4763 const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
4764 Set character font \n\
4765 \n\
4766 DESCRIPTION:\n\
4767 \n\
4768  Sets the default character font for subsequent character drawing. Also\n\
4769  affects symbols produced by plpoin. This routine has no effect unless\n\
4770  the extended character set is loaded (see plfontld). \n\
4771 \n\
4772  Redacted form: plfont(font)\n\
4773 \n\
4774  This function is used in examples 1,2,4,7,13,24,26. \n\
4775 \n\
4776 \n\
4777 \n\
4778 SYNOPSIS:\n\
4779 \n\
4780 plfont(font)\n\
4781 \n\
4782 ARGUMENTS:\n\
4783 \n\
4784  font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
4785  and fastest) \n\
4786  2: Roman font \n\
4787  3: Italic font \n\
4788  4: Script font \n\
4789 ";
4790 const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
4791 Draw a circular or elliptical arc \n\
4792 \n\
4793 DESCRIPTION:\n\
4794 \n\
4795  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
4796  semiminor axis b, starting at angle1 and ending at angle2. \n\
4797 \n\
4798  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
4799  fill)\n\
4800 \n\
4801 \n\
4802  This function is used in examples 3 and 27. \n\
4803 \n\
4804 \n\
4805 \n\
4806 SYNOPSIS:\n\
4807 \n\
4808 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
4809 \n\
4810 ARGUMENTS:\n\
4811 \n\
4812  x (PLFLT, input) : X coordinate of arc center. \n\
4813 \n\
4814  y (PLFLT, input) : Y coordinate of arc center. \n\
4815 \n\
4816  a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
4817 \n\
4818  b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
4819 \n\
4820  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
4821  semimajor axis. \n\
4822 \n\
4823  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
4824  semimajor axis. \n\
4825 \n\
4826  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
4827  X-axis. \n\
4828 \n\
4829  fill (PLBOOL, input) : Draw a filled arc. \n\
4830 ";
4831 const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
4832 Set area fill pattern \n\
4833 \n\
4834 DESCRIPTION:\n\
4835 \n\
4836  Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
4837  parallel lines with specified inclinations and spacings. The\n\
4838  arguments to this routine are the number of sets to use (1 or 2)\n\
4839  followed by two pointers to integer arrays (of 1 or 2 elements)\n\
4840  specifying the inclinations in tenths of a degree and the spacing in\n\
4841  micrometers. (also see plpsty) \n\
4842 \n\
4843  Redacted form: General: plpat(inc, del)\n\
4844 \t Perl/PDL: plpat(nlin, inc, del)\n\
4845 \n\
4846 \n\
4847  This function is used in example 15. \n\
4848 \n\
4849 \n\
4850 \n\
4851 SYNOPSIS:\n\
4852 \n\
4853 plpat(nlin, inc, del)\n\
4854 \n\
4855 ARGUMENTS:\n\
4856 \n\
4857  nlin (PLINT, input) : Number of sets of lines making up the\n\
4858  pattern, either 1 or 2. \n\
4859 \n\
4860  inc (PLINT *, input) : Pointer to array with nlin elements.\n\
4861  Specifies the line inclination in tenths of a degree. (Should be\n\
4862  between -900 and 900). \n\
4863 \n\
4864  del (PLINT *, input) : Pointer to array with nlin elements.\n\
4865  Specifies the spacing in micrometers between the lines making up\n\
4866  the pattern. \n\
4867 ";
4868 const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
4869 Get x axis parameters \n\
4870 \n\
4871 DESCRIPTION:\n\
4872 \n\
4873  Returns current values of the digmax and digits flags for the x axis. \n\
4874  digits is updated after the plot is drawn, so this routine should only\n\
4875  be called after the call to plbox (or plbox3) is complete.\tSee the\n\
4876  PLplot documentation for more information. \n\
4877 \n\
4878  Redacted form: plgxax(digmax, digits)\n\
4879 \n\
4880  This function is used in example 31. \n\
4881 \n\
4882 \n\
4883 \n\
4884 SYNOPSIS:\n\
4885 \n\
4886 plgxax(digmax, digits)\n\
4887 \n\
4888 ARGUMENTS:\n\
4889 \n\
4890  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
4891  number of digits for the x axis. If nonzero, the printed label\n\
4892  has been switched to a floating point representation when the\n\
4893  number of digits exceeds digmax. \n\
4894 \n\
4895  digits (PLINT *, output) : Pointer to variable with the actual\n\
4896  number of digits for the numeric labels (x axis) from the last\n\
4897  plot. \n\
4898 ";
4899 const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
4900 Draw filled polygon in 3D \n\
4901 \n\
4902 DESCRIPTION:\n\
4903 \n\
4904  Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
4905  using the pattern defined by plpsty or plpat. The routine will\n\
4906  automatically close the polygon between the last and first vertices. \n\
4907  If multiple closed polygons are passed in x, y, and z then plfill3\n\
4908  will fill in between them. \n\
4909 \n\
4910  Redacted form: General: plfill3(x, y, z)\n\
4911 \t Perl/PDL: plfill3(n, x, y, z)\n\
4912 \n\
4913 \n\
4914  This function is used in example 15. \n\
4915 \n\
4916 \n\
4917 \n\
4918 SYNOPSIS:\n\
4919 \n\
4920 plfill3(n, x, y, z)\n\
4921 \n\
4922 ARGUMENTS:\n\
4923 \n\
4924  n (PLINT, input) : Number of vertices in polygon. \n\
4925 \n\
4926  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4927  vertices. \n\
4928 \n\
4929  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4930  vertices. \n\
4931 \n\
4932  z (PLFLT *, input) : Pointer to array with z coordinates of\n\
4933  vertices. \n\
4934 ";
4935 const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
4936 Set color, map0 \n\
4937 \n\
4938 DESCRIPTION:\n\
4939 \n\
4940  Sets the color for color map0 (see the PLplot documentation). \n\
4941 \n\
4942  Redacted form: plcol0(color)\n\
4943 \n\
4944  This function is used in examples 1-9,11-16,18-27,29. \n\
4945 \n\
4946 \n\
4947 \n\
4948 SYNOPSIS:\n\
4949 \n\
4950 plcol0(color)\n\
4951 \n\
4952 ARGUMENTS:\n\
4953 \n\
4954  color (PLINT, input) : Integer representing the color. The\n\
4955  defaults at present are (these may change): \n\
4956  0 black (default background) \n\
4957  1 red (default foreground) \n\
4958  2 yellow \n\
4959  3 green \n\
4960  4 aquamarine \n\
4961  5 pink \n\
4962  6 wheat \n\
4963  7 grey \n\
4964  8 brown \n\
4965  9 blue \n\
4966  10 BlueViolet \n\
4967  11 cyan \n\
4968  12 turquoise \n\
4969  13 magenta \n\
4970  14 salmon \n\
4971  15 white \n\
4972 \n\
4973  Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
4974  change an individual color in the map0 color palette. \n\
4975 ";
4976 const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
4977 Draw a line between two points \n\
4978 \n\
4979 DESCRIPTION:\n\
4980 \n\
4981  Joins the point (\n\
4982  x1, \n\
4983  y1) to (\n\
4984  x2, \n\
4985  y2). \n\
4986 \n\
4987  Redacted form: pljoin(x1,y1,x2,y2)\n\
4988 \n\
4989  This function is used in examples 3,14. \n\
4990 \n\
4991 \n\
4992 \n\
4993 SYNOPSIS:\n\
4994 \n\
4995 pljoin(x1, y1, x2, y2)\n\
4996 \n\
4997 ARGUMENTS:\n\
4998 \n\
4999  x1 (PLFLT, input) : x coordinate of first point. \n\
5000 \n\
5001  y1 (PLFLT, input) : y coordinate of first point. \n\
5002 \n\
5003  x2 (PLFLT, input) : x coordinate of second point. \n\
5004 \n\
5005  y2 (PLFLT, input) : y coordinate of second point. \n\
5006 ";
5007 const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
5008 Set color, map1 \n\
5009 \n\
5010 DESCRIPTION:\n\
5011 \n\
5012  Sets the color for color map1 (see the PLplot documentation). \n\
5013 \n\
5014  Redacted form: plcol1(col1)\n\
5015 \n\
5016  This function is used in examples 12 and 21. \n\
5017 \n\
5018 \n\
5019 \n\
5020 SYNOPSIS:\n\
5021 \n\
5022 plcol1(col1)\n\
5023 \n\
5024 ARGUMENTS:\n\
5025 \n\
5026  col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
5027  and is mapped to color using the continuous map1 color palette\n\
5028  which by default ranges from blue to the background color to red. \n\
5029  The map1 palette can also be straightforwardly changed by the user\n\
5030  with plscmap1 or plscmap1l. \n\
5031 ";
5032 const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
5033 Set orientation \n\
5034 \n\
5035 DESCRIPTION:\n\
5036 \n\
5037  Set integer plot orientation parameter. This function is identical to\n\
5038  plsdiori except for the type of the argument, and should be used in\n\
5039  the same way. See the PLplot documentation for details. \n\
5040 \n\
5041  Redacted form: plsori(ori)\n\
5042 \n\
5043  This function is used in example 3. \n\
5044 \n\
5045 \n\
5046 \n\
5047 SYNOPSIS:\n\
5048 \n\
5049 plsori(ori)\n\
5050 \n\
5051 ARGUMENTS:\n\
5052 \n\
5053  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5054  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5055  angle. \n\
5056 ";
5057 const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5058 Plot continental outline in world coordinates. \n\
5059 \n\
5060 DESCRIPTION:\n\
5061 \n\
5062  Plots continental outlines in world coordinates. examples/c/x19c\n\
5063  demonstrates how to use this function to create different\n\
5064  projections. \n\
5065 \n\
5066  Redacted form: General: plmap(mapform, type, minlong, maxlong,\n\
5067  minlat, maxlat)\n\
5068 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
5069 \n\
5070 \n\
5071  This function is used in example 19. \n\
5072 \n\
5073 \n\
5074 \n\
5075 SYNOPSIS:\n\
5076 \n\
5077 plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n\
5078 \n\
5079 ARGUMENTS:\n\
5080 \n\
5081  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5082  supplied function to transform the coordinate longitudes and\n\
5083  latitudes to a plot coordinate system. By using this transform,\n\
5084  we can change from a longitude, latitude coordinate to a polar\n\
5085  stereographic project, for example. Initially, x[0]..[n-1] are\n\
5086  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5087  After the call to mapform(), x[] and y[] should be replaced by\n\
5088  the corresponding plot coordinates. If no transform is desired,\n\
5089  mapform can be replaced by NULL. \n\
5090 \n\
5091  type (char *, input) : type is a character string. The value of\n\
5092  this parameter determines the type of background. The possible\n\
5093  values are: \"globe\" -- continental outlines \n\
5094  \"usa\" -- USA and state boundaries \n\
5095  \"cglobe\" -- continental outlines and countries \n\
5096  \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5097 \n\
5098 \n\
5099  minlong (PLFLT, input) : The value of the longitude on the left\n\
5100  side of the plot. The value of minlong must be less than the\n\
5101  value of maxlong, and the quantity maxlong-minlong must be less\n\
5102  than or equal to 360. \n\
5103 \n\
5104  maxlong (PLFLT, input) : The value of the longitude on the right\n\
5105  side of the plot. \n\
5106 \n\
5107  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
5108  background. One can always use -90.0 as the boundary outside the\n\
5109  plot window will be automatically eliminated. However, the\n\
5110  program will be faster if one can reduce the size of the\n\
5111  background plotted. \n\
5112 \n\
5113  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
5114  background. One can always use 90.0 as the boundary outside the\n\
5115  plot window will be automatically eliminated. \n\
5116 ";
5117 const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
5118 Get current stream number \n\
5119 \n\
5120 DESCRIPTION:\n\
5121 \n\
5122  Gets the number of the current output stream. See also plsstrm. \n\
5123 \n\
5124  Redacted form: plgstrm(strm)\n\
5125 \n\
5126  This function is used in example 1,20. \n\
5127 \n\
5128 \n\
5129 \n\
5130 SYNOPSIS:\n\
5131 \n\
5132 plgstrm(strm)\n\
5133 \n\
5134 ARGUMENTS:\n\
5135 \n\
5136  strm (PLINT *, output) : Pointer to current stream value. \n\
5137 ";
5138 const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
5139 Draw a line in 3 space \n\
5140 \n\
5141 DESCRIPTION:\n\
5142 \n\
5143  Draws line in 3 space defined by n points in x, y, and z. You must\n\
5144  first set up the viewport, the 2d viewing window (in world\n\
5145  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
5146  more info. \n\
5147 \n\
5148  Redacted form: plline3(x, y, z)\n\
5149 \n\
5150  This function is used in example 18. \n\
5151 \n\
5152 \n\
5153 \n\
5154 SYNOPSIS:\n\
5155 \n\
5156 plline3(n, x, y, z)\n\
5157 \n\
5158 ARGUMENTS:\n\
5159 \n\
5160  n (PLINT, input) : Number of points defining line. \n\
5161 \n\
5162  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
5163 \n\
5164  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
5165 \n\
5166  z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
5167 ";
5168 const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
5169 Load character font \n\
5170 \n\
5171 DESCRIPTION:\n\
5172 \n\
5173  Sets the character set to use for subsequent character drawing. May\n\
5174  be called before initializing PLplot. \n\
5175 \n\
5176  Redacted form: plfontld(set)\n\
5177 \n\
5178  This function is used in examples 1,7. \n\
5179 \n\
5180 \n\
5181 \n\
5182 SYNOPSIS:\n\
5183 \n\
5184 plfontld(set)\n\
5185 \n\
5186 ARGUMENTS:\n\
5187 \n\
5188  set (PLINT, input) : Specifies the character set to load: 0:\n\
5189  Standard character set \n\
5190  1: Extended character set \n\
5191 ";
5192 const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
5193 Set any command-line option \n\
5194 \n\
5195 DESCRIPTION:\n\
5196 \n\
5197  Set any command-line option internally from a program before it\n\
5198  invokes plinit. opt is the name of the command-line option and optarg\n\
5199  is the corresponding command-line option argument.\t\n\
5200 \n\
5201  This function returns 0 on success. \n\
5202 \n\
5203  Redacted form: plsetopt(opt, optarg)\n\
5204 \n\
5205  This function is used in example 14. \n\
5206 \n\
5207 \n\
5208 \n\
5209 SYNOPSIS:\n\
5210 \n\
5211 int plsetopt(opt, optarg)\n\
5212 \n\
5213 ARGUMENTS:\n\
5214 \n\
5215  opt (const char *, input) : Pointer to string containing the\n\
5216  command-line option. \n\
5217 \n\
5218  optarg (const char *, input) : Pointer to string containing the\n\
5219  argument of the command-line option. \n\
5220 ";
5221 const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
5222 Used to globally turn color output on/off \n\
5223 \n\
5224 DESCRIPTION:\n\
5225 \n\
5226  Used to globally turn color output on/off for those drivers/devices\n\
5227  that support it. \n\
5228 \n\
5229  Redacted form: plscolor(color)\n\
5230 \n\
5231  This function is used in example 31. \n\
5232 \n\
5233 \n\
5234 \n\
5235 SYNOPSIS:\n\
5236 \n\
5237 plscolor(color)\n\
5238 \n\
5239 ARGUMENTS:\n\
5240 \n\
5241  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
5242  turned off. If non-zero, color is turned on. \n\
5243 ";
5244 const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
5245 Get the current device (keyword) name \n\
5246 \n\
5247 DESCRIPTION:\n\
5248 \n\
5249  Get the current device (keyword) name. Note: you must have allocated\n\
5250  space for this (80 characters is safe). \n\
5251 \n\
5252  Redacted form: plgdev(p_dev)\n\
5253 \n\
5254  This function is used in example 14. \n\
5255 \n\
5256 \n\
5257 \n\
5258 SYNOPSIS:\n\
5259 \n\
5260 plgdev(p_dev)\n\
5261 \n\
5262 ARGUMENTS:\n\
5263 \n\
5264  p_dev (char *, output) : Pointer to device (keyword) name string. \n\
5265 ";
5266 const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
5267 Add a point to a strip chart \n\
5268 \n\
5269 DESCRIPTION:\n\
5270 \n\
5271  Add a point to a given pen of a given strip chart. There is no need\n\
5272  for all pens to have the same number of points or to be equally\n\
5273  sampled in the x coordinate. Allocates memory and rescales as\n\
5274  necessary. \n\
5275 \n\
5276  Redacted form: plstripa(id, p, x, y)\n\
5277 \n\
5278  This function is used in example 17. \n\
5279 \n\
5280 \n\
5281 \n\
5282 SYNOPSIS:\n\
5283 \n\
5284 plstripa(id, p, x, y)\n\
5285 \n\
5286 ARGUMENTS:\n\
5287 \n\
5288  id (PLINT, input) : Identification number (set up in plstripc) of\n\
5289  the strip chart. \n\
5290 \n\
5291  p (PLINT, input) : Pen number (ranges from 0 to 3). \n\
5292 \n\
5293  x (PLFLT, input) : X coordinate of point to plot. \n\
5294 \n\
5295  y (PLFLT, input) : Y coordinate of point to plot. \n\
5296 ";
5297 const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
5298 Deletes and releases memory used by a strip chart \n\
5299 \n\
5300 DESCRIPTION:\n\
5301 \n\
5302  Deletes and releases memory used by a strip chart. \n\
5303 \n\
5304  Redacted form: plstripd(id)\n\
5305 \n\
5306  This function is used in example 17. \n\
5307 \n\
5308 \n\
5309 \n\
5310 SYNOPSIS:\n\
5311 \n\
5312 plstripd(id)\n\
5313 \n\
5314 ARGUMENTS:\n\
5315 \n\
5316  id (PLINT, input) : Identification number of strip chart to delete. \n\
5317 ";
5318 const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5319 Specify viewport using coordinates and aspect ratio \n\
5320 \n\
5321 DESCRIPTION:\n\
5322 \n\
5323  Device-independent routine for setting up the viewport. The viewport\n\
5324  is chosen to be the largest with the given aspect ratio that fits\n\
5325  within the specified region (in terms of normalized subpage\n\
5326  coordinates). This routine is functionally equivalent to plvpor when\n\
5327  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5328  routine reserves no extra space at the edges for labels. \n\
5329 \n\
5330  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5331 \n\
5332  This function is used in example 9. \n\
5333 \n\
5334 \n\
5335 \n\
5336 SYNOPSIS:\n\
5337 \n\
5338 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5339 \n\
5340 ARGUMENTS:\n\
5341 \n\
5342  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5343  left-hand edge of the viewport. \n\
5344 \n\
5345  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5346  right-hand edge of the viewport. \n\
5347 \n\
5348  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5349  bottom edge of the viewport. \n\
5350 \n\
5351  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5352  edge of the viewport. \n\
5353 \n\
5354  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5355  axis. \n\
5356 ";
5357 const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
5358 Assign a function to use for generating custom axis labels \n\
5359 \n\
5360 DESCRIPTION:\n\
5361 \n\
5362  This function allows a user to provide their own function to provide\n\
5363  axis label text. The user function is given the numeric value for a\n\
5364  point on an axis and returns a string label to correspond with that\n\
5365  value. Custom axis labels can be enabled by passing appropriate\n\
5366  arguments to plenv, plbox, plbox3 and similar functions. \n\
5367 \n\
5368  This function is used in example 19. \n\
5369 \n\
5370 \n\
5371 \n\
5372 SYNOPSIS:\n\
5373 \n\
5374 plslabelfunc(label_func, label_data)\n\
5375 \n\
5376 ARGUMENTS:\n\
5377 \n\
5378  label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n\
5379  This is the custom label function. In order to reset to the\n\
5380  default labelling, set this to NULL. The labelling function\n\
5381  parameters are, in order: axis: This indicates which axis a\n\
5382  label is being requested for. The value will be one of PL_X_AXIS,\n\
5383  PL_Y_AXIS or PL_Z_AXIS. \n\
5384 \n\
5385  value: This is the value along the axis which is being labelled. \n\
5386 \n\
5387  label_text: The string representation of the label value. \n\
5388 \n\
5389  length: The maximum length in characters allowed for label_text. \n\
5390 \n\
5391 \n\
5392  label_data (void *, input) : This parameter may be used to pass\n\
5393  data to the label_func function. \n\
5394 ";
5395 const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
5396 Set length of major ticks \n\
5397 \n\
5398 DESCRIPTION:\n\
5399 \n\
5400  This sets up the length of the major ticks. The actual length is the\n\
5401  product of the default length and a scaling factor as for character\n\
5402  height. \n\
5403 \n\
5404  Redacted form: plsmaj(def, scale)\n\
5405 \n\
5406  This function is used in example 29. \n\
5407 \n\
5408 \n\
5409 \n\
5410 SYNOPSIS:\n\
5411 \n\
5412 plsmaj(def, scale)\n\
5413 \n\
5414 ARGUMENTS:\n\
5415 \n\
5416  def (PLFLT, input) : The default length of a major tick in\n\
5417  millimeters, should be set to zero if the default length is to\n\
5418  remain unchanged. \n\
5419 \n\
5420  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
5421  actual tick length. \n\
5422 ";
5423 const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
5424 Get the current library version number \n\
5425 \n\
5426 DESCRIPTION:\n\
5427 \n\
5428  Get the current library version number. Note: you must have allocated\n\
5429  space for this (80 characters is safe). \n\
5430 \n\
5431  Redacted form: plgver(p_ver)\n\
5432 \n\
5433  This function is used in example 1. \n\
5434 \n\
5435 \n\
5436 \n\
5437 SYNOPSIS:\n\
5438 \n\
5439 plgver(p_ver)\n\
5440 \n\
5441 ARGUMENTS:\n\
5442 \n\
5443  p_ver (char *, output) : Pointer to the current library version\n\
5444  number. \n\
5445 ";
5446 const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
5447 Set format of numerical label for contours\n\
5448 \n\
5449 DESCRIPTION:\n\
5450 \n\
5451  Set format of numerical label for contours. \n\
5452 \n\
5453  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
5454 \n\
5455  This function is used example 9. \n\
5456 \n\
5457 \n\
5458 \n\
5459 SYNOPSIS:\n\
5460 \n\
5461 pl_setcontlabelformat(lexp, sigdig)\n\
5462 \n\
5463 ARGUMENTS:\n\
5464 \n\
5465  lexp (PLINT, input) : If the contour numerical label is greater\n\
5466  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
5467  format is used. Default value of lexp is 4. \n\
5468 \n\
5469  sigdig (PLINT, input) : Number of significant digits. Default\n\
5470  value is 2. \n\
5471 ";
5472 const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
5473 Parse command-line arguments \n\
5474 \n\
5475 DESCRIPTION:\n\
5476 \n\
5477  Parse command-line arguments. \n\
5478 \n\
5479  plparseopts removes all recognized flags (decreasing argc\n\
5480  accordingly), so that invalid input may be readily detected. It can\n\
5481  also be used to process user command line flags. The user can merge\n\
5482  an option table of type PLOptionTable into the internal option table\n\
5483  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
5484  the external table(s) be parsed by calling plClearOpts before\n\
5485  plMergeOpts. \n\
5486 \n\
5487  The default action taken by plparseopts is as follows: \n\
5488  Returns with an error if an unrecognized option or badly formed\n\
5489  option-value pair are encountered.\t\n\
5490  Returns immediately (return code 0) when the first non-option command\n\
5491  line argument is found. \n\
5492  Returns with the return code of the option handler, if one was called.\n\
5493  \n\
5494  Deletes command line arguments from argv list as they are found, and\n\
5495  decrements argc accordingly. \n\
5496  Does not show \"invisible\" options in usage or help messages. \n\
5497  Assumes the program name is contained in argv[0]. \n\
5498 \n\
5499  These behaviors may be controlled through the \n\
5500  mode argument. \n\
5501 \n\
5502  Redacted form: General: plparseopts(argv, mode)\n\
5503 \t Perl/PDL: Not available? \n\
5504 \n\
5505 \n\
5506  This function is used in all of the examples. \n\
5507 \n\
5508 \n\
5509 \n\
5510 SYNOPSIS:\n\
5511 \n\
5512 int plparseopts(p_argc, argv, mode)\n\
5513 \n\
5514 ARGUMENTS:\n\
5515 \n\
5516  p_argc (int *, input) : pointer to number of arguments. \n\
5517 \n\
5518  argv (char **, input) : Pointer to character array containing\n\
5519  *p_argc command-line arguments. \n\
5520 \n\
5521  mode (PLINT, input) : Parsing mode with the following\n\
5522  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
5523  and all error messages enabled, including program exit when an\n\
5524  error occurs. Anything on the command line that isn\'t recognized\n\
5525  as a valid option or option argument is flagged as an error. \n\
5526  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
5527  of errors. \n\
5528  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
5529  arguments. \n\
5530  PL_PARSE_SHOWALL (8) -- Show invisible options \n\
5531  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
5532  pointer to the program name. \n\
5533  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
5534  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
5535  unrecognized arguments. \n\
5536 ";
5537 const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
5538 Initialization \n\
5539 \n\
5540 DESCRIPTION:\n\
5541 \n\
5542  Initializing the plotting package.\tThe program prompts for the device\n\
5543  keyword or number of the desired output device. Hitting a RETURN in\n\
5544  response to the prompt is the same as selecting the first device. If\n\
5545  only one device is enabled when PLplot is installed, plstar will issue\n\
5546  no prompt.\tThe output device is divided into nx by ny subpages, each\n\
5547  of which may be used independently. The subroutine pladv is used to\n\
5548  advance from one subpage to the next. \n\
5549 \n\
5550  Redacted form: plstar(nx, ny)\n\
5551 \n\
5552  This function is used in example 1. \n\
5553 \n\
5554 \n\
5555 \n\
5556 SYNOPSIS:\n\
5557 \n\
5558 plstar(nx, ny)\n\
5559 \n\
5560 ARGUMENTS:\n\
5561 \n\
5562  nx (PLINT, input) : Number of subpages to divide output page in the\n\
5563  horizontal direction. \n\
5564 \n\
5565  ny (PLINT, input) : Number of subpages to divide output page in the\n\
5566  vertical direction. \n\
5567 ";
5568 const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
5569 Get FCI (font characterization integer) \n\
5570 \n\
5571 DESCRIPTION:\n\
5572 \n\
5573  Gets information about the current font using the FCI approach. See\n\
5574  the PLplot documentation for more information. \n\
5575 \n\
5576  Redacted form: plgfci(fci)\n\
5577 \n\
5578  This function is used in example 23. \n\
5579 \n\
5580 \n\
5581 \n\
5582 SYNOPSIS:\n\
5583 \n\
5584 plgfci(fci)\n\
5585 \n\
5586 ARGUMENTS:\n\
5587 \n\
5588  fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
5589  integer) variable which is updated with current FCI value. \n\
5590 ";
5591 const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
5592 Set family file parameters \n\
5593 \n\
5594 DESCRIPTION:\n\
5595 \n\
5596  Sets variables dealing with output file familying.\tDoes nothing if\n\
5597  familying not supported by the driver. This routine, if used, must be\n\
5598  called before initializing PLplot.\tSee the PLplot documentation for\n\
5599  more information. \n\
5600 \n\
5601  Redacted form: plsfam(fam, num, bmax)\n\
5602 \n\
5603  This function is used in examples 14,31. \n\
5604 \n\
5605 \n\
5606 \n\
5607 SYNOPSIS:\n\
5608 \n\
5609 plsfam(fam, num, bmax)\n\
5610 \n\
5611 ARGUMENTS:\n\
5612 \n\
5613  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
5614  is enabled. \n\
5615 \n\
5616  num (PLINT, input) : Current family file number. \n\
5617 \n\
5618  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
5619  file. \n\
5620 ";
5621 const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
5622 Set color map1 colors using a piece-wise linear relationship \n\
5623 \n\
5624 DESCRIPTION:\n\
5625 \n\
5626  This is a version of plscmap1l that supports alpha transparency. It\n\
5627  sets color map1 colors using a piece-wise linear relationship between\n\
5628  position in the color map (from 0 to 1) and position in HLS or RGB\n\
5629  color space (see the PLplot documentation) with alpha value (0.0 -\n\
5630  1.0). It may be called at any time. \n\
5631 \n\
5632  This function is used in example 30. \n\
5633 \n\
5634 \n\
5635 \n\
5636 SYNOPSIS:\n\
5637 \n\
5638 plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n\
5639 \n\
5640 ARGUMENTS:\n\
5641 \n\
5642  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
5643 \n\
5644  npts (PLINT, input) : number of control points \n\
5645 \n\
5646  pos (PLFLT *, input) : position for each control point (between 0.0\n\
5647  and 1.0, in ascending order) \n\
5648 \n\
5649  coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
5650  control point \n\
5651 \n\
5652  coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
5653  control point \n\
5654 \n\
5655  coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
5656  control point \n\
5657 \n\
5658  coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n\
5659  each control point \n\
5660 \n\
5661  alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
5662  flag for each control point. (alt_hue_path[i] refers to the\n\
5663  interpolation interval between the i and i + 1 control points). \n\
5664 ";
5665 const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5666 Set page parameters \n\
5667 \n\
5668 DESCRIPTION:\n\
5669 \n\
5670  Sets the page configuration (optional). If an individual parameter is\n\
5671  zero then that parameter value is not updated. Not all parameters are\n\
5672  recognized by all drivers and the interpretation is device-dependent.\n\
5673  The X-window driver uses the length and offset parameters to determine\n\
5674  the window size and location. The length and offset values are\n\
5675  expressed in units that are specific to the current driver. For\n\
5676  instance: screen drivers will usually interpret them as number of\n\
5677  pixels, whereas printer drivers will usually use mm. This routine, if\n\
5678  used, must be called before initializing PLplot. \n\
5679 \n\
5680  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5681 \n\
5682  This function is used in examples 14 and 31. \n\
5683 \n\
5684 \n\
5685 \n\
5686 SYNOPSIS:\n\
5687 \n\
5688 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5689 \n\
5690 ARGUMENTS:\n\
5691 \n\
5692  xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
5693 \n\
5694  yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
5695 \n\
5696  xleng (PLINT , input) : Page length, x. \n\
5697 \n\
5698  yleng (PLINT, input) : Page length, y. \n\
5699 \n\
5700  xoff (PLINT, input) : Page offset, x. \n\
5701 \n\
5702  yoff (PLINT, input) : Page offset, y. \n\
5703 ";
5704 const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
5705 Set precision in numeric labels \n\
5706 \n\
5707 DESCRIPTION:\n\
5708 \n\
5709  Sets the number of places after the decimal point in numeric labels. \n\
5710 \n\
5711  Redacted form: plprec(set, prec)\n\
5712 \n\
5713  This function is used in example 29. \n\
5714 \n\
5715 \n\
5716 \n\
5717 SYNOPSIS:\n\
5718 \n\
5719 plprec(set, prec)\n\
5720 \n\
5721 ARGUMENTS:\n\
5722 \n\
5723  set (PLINT, input) : If set is equal to 0 then PLplot automatically\n\
5724  determines the number of places to use after the decimal point in\n\
5725  numeric labels (like those used to label axes). If set is 1 then\n\
5726  prec sets the number of places. \n\
5727 \n\
5728  prec (PLINT, input) : The number of characters to draw after the\n\
5729  decimal point in numeric labels. \n\
5730 ";
5731 const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5732 Copy state parameters from the reference stream to the current stream \n\
5733 \n\
5734 DESCRIPTION:\n\
5735 \n\
5736  Copies state parameters from the reference stream to the current\n\
5737  stream. Tell driver interface to map device coordinates unless flags\n\
5738  == 1. \n\
5739 \n\
5740  This function is used for making save files of selected plots (e.g.\n\
5741  from the TK driver). After initializing, you can get a copy of the\n\
5742  current plot to the specified device by switching to this stream and\n\
5743  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5744  appropriate. The plot buffer must have previously been enabled (done\n\
5745  automatically by some display drivers, such as X). \n\
5746 \n\
5747  Redacted form: plcpstrm(iplsr, flags)\n\
5748 \n\
5749  This function is used in example 1,20. \n\
5750 \n\
5751 \n\
5752 \n\
5753 SYNOPSIS:\n\
5754 \n\
5755 plcpstrm(iplsr, flags)\n\
5756 \n\
5757 ARGUMENTS:\n\
5758 \n\
5759  iplsr (PLINT, input) : Number of reference stream. \n\
5760 \n\
5761  flags (PLBOOL, input) : If flags is set to true the device\n\
5762  coordinates are not copied from the reference to current stream. \n\
5763 ";
5764 const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
5765 Plot a glyph at the specified points \n\
5766 \n\
5767 DESCRIPTION:\n\
5768 \n\
5769  Plot a glyph at the specified points. (This function is largely\n\
5770  superseded by plstring which gives access to many[!] more glyphs.)\n\
5771  code=-1 means try to just draw a point. Right now it\'s just a move\n\
5772  and a draw at the same place. Not ideal, since a sufficiently\n\
5773  intelligent output device may optimize it away, or there may be faster\n\
5774  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5775  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5776  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5777  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5778  code <= 127 the corresponding printable ASCII character is plotted. \n\
5779 \n\
5780  Redacted form: plpoin(x, y, code)\n\
5781 \n\
5782  This function is used in examples 1,6,14,29. \n\
5783 \n\
5784 \n\
5785 \n\
5786 SYNOPSIS:\n\
5787 \n\
5788 plpoin(n, x, y, code)\n\
5789 \n\
5790 ARGUMENTS:\n\
5791 \n\
5792  n (PLINT, input) : Number of points in the x and y arrays. \n\
5793 \n\
5794  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
5795  points. \n\
5796 \n\
5797  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
5798  points. \n\
5799 \n\
5800  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5801  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5802  each of the n points. \n\
5803 ";
5804 const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
5805 Enter or leave xor mode \n\
5806 \n\
5807 DESCRIPTION:\n\
5808 \n\
5809  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
5810  those drivers (e.g., the xwin driver) that support it. Enables\n\
5811  erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
5812  is not capable of xor operation it returns a status of false. \n\
5813 \n\
5814  Redacted form: plxormod(mode, status)\n\
5815 \n\
5816  This function is used in examples 1,20. \n\
5817 \n\
5818 \n\
5819 \n\
5820 SYNOPSIS:\n\
5821 \n\
5822 plxormod(mode, status)\n\
5823 \n\
5824 ARGUMENTS:\n\
5825 \n\
5826  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
5827  is false means leave xor mode. \n\
5828 \n\
5829  status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
5830  of true (false) means driver is capable (incapable) of xor mode. \n\
5831 ";
5832 const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
5833 Get viewport limits in normalized device coordinates \n\
5834 \n\
5835 DESCRIPTION:\n\
5836 \n\
5837  Get viewport limits in normalized device coordinates. \n\
5838 \n\
5839  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5840 \t Perl/PDL: Not available? \n\
5841 \n\
5842 \n\
5843  This function is used in example 31. \n\
5844 \n\
5845 \n\
5846 \n\
5847 SYNOPSIS:\n\
5848 \n\
5849 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5850 \n\
5851 ARGUMENTS:\n\
5852 \n\
5853  p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5854  device coordinate in x. \n\
5855 \n\
5856  p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5857  device coordinate in x. \n\
5858 \n\
5859  p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5860  device coordinate in y. \n\
5861 \n\
5862  p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5863  device coordinate in y. \n\
5864 ";
5865 const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
5866 End plotting session for current stream \n\
5867 \n\
5868 DESCRIPTION:\n\
5869 \n\
5870  Ends a plotting session for the current output stream only. See\n\
5871  plsstrm for more info. \n\
5872 \n\
5873  Redacted form: plend1()\n\
5874 \n\
5875  This function is used in examples 1,20. \n\
5876 \n\
5877 \n\
5878 \n\
5879 SYNOPSIS:\n\
5880 \n\
5881 plend1()\n\
5882 ";
5883 const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
5884 Get y axis parameters \n\
5885 \n\
5886 DESCRIPTION:\n\
5887 \n\
5888  Identical to plgxax, except that arguments are flags for y axis. See\n\
5889  the description of plgxax for more detail. \n\
5890 \n\
5891  Redacted form: plgyax(digmax, digits)\n\
5892 \n\
5893  This function is used in example 31. \n\
5894 \n\
5895 \n\
5896 \n\
5897 SYNOPSIS:\n\
5898 \n\
5899 plgyax(digmax, digits)\n\
5900 \n\
5901 ARGUMENTS:\n\
5902 \n\
5903  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5904  number of digits for the y axis. If nonzero, the printed label\n\
5905  has been switched to a floating point representation when the\n\
5906  number of digits exceeds digmax. \n\
5907 \n\
5908  digits (PLINT *, output) : Pointer to variable with the actual\n\
5909  number of digits for the numeric labels (y axis) from the last\n\
5910  plot. \n\
5911 ";
5912 const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
5913 Set plot orientation \n\
5914 \n\
5915 DESCRIPTION:\n\
5916 \n\
5917  Set plot orientation parameter which is multiplied by 90 degrees to\n\
5918  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
5919  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
5920  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
5921  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
5922  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
5923  not called the default value of rot is 0. \n\
5924 \n\
5925  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
5926  probably want to change the aspect ratio to a value suitable for the\n\
5927  plot orientation using a call to plsdidev or the command-line options\n\
5928  -a or -freeaspect.\tFor more documentation of those options see the\n\
5929  PLplot documentation. Such command-line options can be set internally\n\
5930  using plsetopt or set directly using the command line and parsed using\n\
5931  a call to plparseopts. \n\
5932 \n\
5933  Redacted form: plsdiori(rot)\n\
5934 \n\
5935  This function is not used in any examples. \n\
5936 \n\
5937 \n\
5938 \n\
5939 SYNOPSIS:\n\
5940 \n\
5941 plsdiori(rot)\n\
5942 \n\
5943 ARGUMENTS:\n\
5944 \n\
5945  rot (PLFLT, input) : Plot orientation parameter. \n\
5946 ";
5947 const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
5948 Plot a histogram from unbinned data \n\
5949 \n\
5950 DESCRIPTION:\n\
5951 \n\
5952  Plots a histogram from n data points stored in the array data. This\n\
5953  routine bins the data into nbin bins equally spaced between datmin and\n\
5954  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
5955  opt allows, among other things, the histogram either to be plotted in\n\
5956  an existing window or causes plhist to call plenv with suitable limits\n\
5957  before plotting the histogram. \n\
5958 \n\
5959  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
5960 \n\
5961  This function is used in example 5. \n\
5962 \n\
5963 \n\
5964 \n\
5965 SYNOPSIS:\n\
5966 \n\
5967 plhist(n, data, datmin, datmax, nbin, opt)\n\
5968 \n\
5969 ARGUMENTS:\n\
5970 \n\
5971  n (PLINT, input) : Number of data points. \n\
5972 \n\
5973  data (PLFLT *, input) : Pointer to array with values of the n data\n\
5974  points. \n\
5975 \n\
5976  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
5977 \n\
5978  datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
5979 \n\
5980  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
5981  divide the interval xmin to xmax. \n\
5982 \n\
5983  opt (PLINT, input) : Is a combination of several flags:\n\
5984  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
5985  the histogram data, the outer bins are expanded to fill up the\n\
5986  entire x-axis, data outside the given extremes are assigned to the\n\
5987  outer bins and bins of zero height are simply drawn. \n\
5988  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
5989  to fit the histogram data, without this flag, plenv is called\n\
5990  to set the world coordinates. \n\
5991  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
5992  extremes are not taken into account. This option should\n\
5993  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
5994  properly present the data. \n\
5995  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
5996  size as the ones inside. \n\
5997  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
5998  (there is a gap for such bins). \n\
5999 ";
6000 const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6001 End plotting session \n\
6002 \n\
6003 DESCRIPTION:\n\
6004 \n\
6005  Ends a plotting session, tidies up all the output files, switches\n\
6006  interactive devices back into text mode and frees up any memory that\n\
6007  was allocated. Must be called before end of program. \n\
6008 \n\
6009  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6010  wait state after a call to plend or other functions which trigger the\n\
6011  end of a plot page. To avoid this, use the plspause function. \n\
6012 \n\
6013  Redacted form: plend()\n\
6014 \n\
6015  This function is used in all of the examples. \n\
6016 \n\
6017 \n\
6018 \n\
6019 SYNOPSIS:\n\
6020 \n\
6021 plend()\n\
6022 ";
6023 const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
6024 Set device-compression level \n\
6025 \n\
6026 DESCRIPTION:\n\
6027 \n\
6028  Set device-compression level. Only used for drivers that provide\n\
6029  compression. This function, if used, should be invoked before a call\n\
6030  to plinit.\t\n\
6031 \n\
6032  Redacted form: plscompression(compression)\n\
6033 \n\
6034  This function is used in example 31. \n\
6035 \n\
6036 \n\
6037 \n\
6038 SYNOPSIS:\n\
6039 \n\
6040 plscompression(compression)\n\
6041 \n\
6042 ARGUMENTS:\n\
6043 \n\
6044  compression (PLINT, input) : The desired compression level. This is\n\
6045  a device-dependent value. Currently only the jpeg and png devices\n\
6046  use these values. For jpeg value is the jpeg quality which should\n\
6047  normally be in the range 0-95. Higher values denote higher quality\n\
6048  and hence larger image sizes. For png values are in the range -1\n\
6049  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
6050  A value of -1 denotes the default zlib compression level. Values\n\
6051  in the range 10-99 are divided by 10 and then used as the zlib\n\
6052  compression level. Higher compression levels correspond to greater\n\
6053  compression and small file sizes at the expense of more\n\
6054  computation. \n\
6055 ";
6056 const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
6057 Get the current device-compression setting \n\
6058 \n\
6059 DESCRIPTION:\n\
6060 \n\
6061  Get the current device-compression setting. This parameter is only\n\
6062  used for drivers that provide compression. \n\
6063 \n\
6064  Redacted form: plgcompression(compression)\n\
6065 \n\
6066  This function is used in example 31. \n\
6067 \n\
6068 \n\
6069 \n\
6070 SYNOPSIS:\n\
6071 \n\
6072 plgcompression(compression)\n\
6073 \n\
6074 ARGUMENTS:\n\
6075 \n\
6076  compression (PLINT *, output) : Pointer to a variable to be filled\n\
6077  with the current device-compression setting. \n\
6078 ";
6079 const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
6080 Advance the (sub-)page\n\
6081 \n\
6082 DESCRIPTION:\n\
6083 \n\
6084  Advances to the next subpage if sub=0, performing a page advance if\n\
6085  there are no remaining subpages on the current page. If subpages\n\
6086  aren\'t being used, pladv(0) will always advance the page. If sub>0,\n\
6087  PLplot switches to the specified subpage. Note that this allows you\n\
6088  to overwrite a plot on the specified subpage; if this is not what you\n\
6089  intended, use pleop followed by plbop to first advance the page. This\n\
6090  routine is called automatically (with sub=0) by plenv, but if plenv is\n\
6091  not used, pladv must be called after initializing PLplot but before\n\
6092  defining the viewport. \n\
6093 \n\
6094  Redacted form: pladv(sub)\n\
6095 \n\
6096  This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
6097 \n\
6098 \n\
6099 \n\
6100 SYNOPSIS:\n\
6101 \n\
6102 pladv(sub)\n\
6103 \n\
6104 ARGUMENTS:\n\
6105 \n\
6106  sub (PLINT, input) : Specifies the subpage number (starting from 1\n\
6107  in the top left corner and increasing along the rows) to which to\n\
6108  advance. Set to zero to advance to the next subpage. \n\
6109 ";
6110 const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
6111 Set parameters of contour labelling other than format of numerical label\n\
6112 \n\
6113 DESCRIPTION:\n\
6114 \n\
6115  Set parameters of contour labelling other than those handled by\n\
6116  pl_setcontlabelformat. \n\
6117 \n\
6118  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
6119 \n\
6120  This function is used in example 9. \n\
6121 \n\
6122 \n\
6123 \n\
6124 SYNOPSIS:\n\
6125 \n\
6126 pl_setcontlabelparam(offset, size, spacing, active)\n\
6127 \n\
6128 ARGUMENTS:\n\
6129 \n\
6130  offset (PLFLT, input) : Offset of label from contour line (if set\n\
6131  to 0.0, labels are printed on the lines). Default value is 0.006. \n\
6132 \n\
6133  size (PLFLT, input) : Font height for contour labels (normalized). \n\
6134  Default value is 0.3. \n\
6135 \n\
6136  spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
6137  Default value is 0.1. \n\
6138 \n\
6139  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
6140  contour labels on. Default is off (0). \n\
6141 ";
6142 const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
6143 Set family, style and weight of the current font \n\
6144 \n\
6145 DESCRIPTION:\n\
6146 \n\
6147  Sets the current font. See the PLplot documentation for more\n\
6148  information on font selection. \n\
6149 \n\
6150  Redacted form: plsfont(family, style, weight)\n\
6151 \n\
6152  This function is used in example 23. \n\
6153 \n\
6154 \n\
6155 \n\
6156 SYNOPSIS:\n\
6157 \n\
6158 plsfont(family, style, weight)\n\
6159 \n\
6160 ARGUMENTS:\n\
6161 \n\
6162  family (PLINT, input) : Font family to select for the current font.\n\
6163  The available values are given by the PL_FCI_* constants in\n\
6164  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n\
6165  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
6166  signifies that the font family should not be altered. \n\
6167 \n\
6168  style (PLINT, input) : Font style to select for the current font.\n\
6169  The available values are given by the PL_FCI_* constants in\n\
6170  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
6171  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
6172  should not be altered. \n\
6173 \n\
6174  weight (PLINT, input) : Font weight to select for the current font.\n\
6175  The available values are given by the PL_FCI_* constants in\n\
6176  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
6177  negative value signifies that the font weight should not be\n\
6178  altered. \n\
6179 ";
6180 const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6181 Sets the 3D position of the light source \n\
6182 \n\
6183 DESCRIPTION:\n\
6184 \n\
6185  Sets the 3D position of the light source for use with plsurf3d. \n\
6186 \n\
6187  Redacted form: pllightsource(x, y, z)\n\
6188 \n\
6189  This function is used in example 8. \n\
6190 \n\
6191 \n\
6192 \n\
6193 SYNOPSIS:\n\
6194 \n\
6195 pllightsource(x, y, z)\n\
6196 \n\
6197 ARGUMENTS:\n\
6198 \n\
6199  x (PLFLT, input) : X-coordinate of the light source. \n\
6200 \n\
6201  y (PLFLT, input) : Y-coordinate of the light source. \n\
6202 \n\
6203  z (PLFLT, input) : Z-coordinate of the light source. \n\
6204 ";
6205 const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
6206 Draw a line \n\
6207 \n\
6208 DESCRIPTION:\n\
6209 \n\
6210  Draws line defined by n points in x and y. \n\
6211 \n\
6212  Redacted form: plline(x, y)\n\
6213 \n\
6214  This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
6215 \n\
6216 \n\
6217 \n\
6218 SYNOPSIS:\n\
6219 \n\
6220 plline(n, x, y)\n\
6221 \n\
6222 ARGUMENTS:\n\
6223 \n\
6224  n (PLINT, input) : Number of points defining line. \n\
6225 \n\
6226  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
6227 \n\
6228  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
6229 ";
6230 const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
6231 Set pen width \n\
6232 \n\
6233 DESCRIPTION:\n\
6234 \n\
6235  Sets the pen width. \n\
6236 \n\
6237  Redacted form: plwidth(width)\n\
6238 \n\
6239  This function is used in examples 1,2. \n\
6240 \n\
6241 \n\
6242 \n\
6243 SYNOPSIS:\n\
6244 \n\
6245 plwidth(width)\n\
6246 \n\
6247 ARGUMENTS:\n\
6248 \n\
6249  width (PLFLT, input) : The desired pen width. If width is negative\n\
6250  or the same as the previous value no action is taken. width = 0.\n\
6251  should be interpreted as as the minimum valid pen width for the\n\
6252  device. The interpretation of positive width values is also\n\
6253  device dependent. \n\
6254 ";
6255 const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
6256 Draw linear gradient inside polygon \n\
6257 \n\
6258 DESCRIPTION:\n\
6259 \n\
6260  Draw a linear gradient using colour map 1 inside the polygon defined\n\
6261  by the n points (\n\
6262  x[i], \n\
6263  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
6264  polygon coordinates and the gradient angle are all expressed in world\n\
6265  coordinates. The angle from the x axis for both the rotated\n\
6266  coordinate system and the gradient vector is specified by angle. The\n\
6267  magnitude of the gradient vector is the difference between the maximum\n\
6268  and minimum values of x for the vertices in the rotated coordinate\n\
6269  system. The origin of the gradient vector can be interpreted as being\n\
6270  anywhere on the line corresponding to the minimum x value for the\n\
6271  vertices in the rotated coordinate system.\tThe distance along the\n\
6272  gradient vector is linearly transformed to the independent variable of\n\
6273  colour map 1 which ranges from 0. at the tail of the gradient vector\n\
6274  to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
6275  colour corresponding to the independent variable of colour map 1. For\n\
6276  more information about colour map 1 (see the PLplot documentation). \n\
6277 \n\
6278  Redacted form: plgradient(x,y,angle)\n\
6279 \n\
6280  This function is used in examples 25,30. \n\
6281 \n\
6282 \n\
6283 \n\
6284 SYNOPSIS:\n\
6285 \n\
6286 plgradient(n, x, y, angle)\n\
6287 \n\
6288 ARGUMENTS:\n\
6289 \n\
6290  n (PLINT, input) : Number of vertices in polygon. \n\
6291 \n\
6292  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
6293  vertices. \n\
6294 \n\
6295  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
6296  vertices. \n\
6297 \n\
6298  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
6299  axis. \n\
6300 ";
6301 const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
6302 Flushes the output stream \n\
6303 \n\
6304 DESCRIPTION:\n\
6305 \n\
6306  Flushes the output stream. Use sparingly, if at all. \n\
6307 \n\
6308  Redacted form: plflush()\n\
6309 \n\
6310  This function is used in examples 1,14. \n\
6311 \n\
6312 \n\
6313 \n\
6314 SYNOPSIS:\n\
6315 \n\
6316 plflush()\n\
6317 ";
6318 const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
6319 Get plot orientation \n\
6320 \n\
6321 DESCRIPTION:\n\
6322 \n\
6323  Get plot orientation parameter which is multiplied by 90 degrees to\n\
6324  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
6325  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
6326  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
6327  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
6328  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
6329  not been called the default value pointed to by p_rot will be 0. \n\
6330 \n\
6331  Redacted form: plgdiori(p_rot)\n\
6332 \n\
6333  This function is not used in any examples. \n\
6334 \n\
6335 \n\
6336 \n\
6337 SYNOPSIS:\n\
6338 \n\
6339 plgdiori(p_rot)\n\
6340 \n\
6341 ARGUMENTS:\n\
6342 \n\
6343  p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
6344 ";
6345 const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
6346 Set x axis parameters \n\
6347 \n\
6348 DESCRIPTION:\n\
6349 \n\
6350  Sets values of the digmax and digits flags for the x axis.\tSee the\n\
6351  PLplot documentation for more information. \n\
6352 \n\
6353  Redacted form: plsxax(digmax, digits)\n\
6354 \n\
6355  This function is used in example 31. \n\
6356 \n\
6357 \n\
6358 \n\
6359 SYNOPSIS:\n\
6360 \n\
6361 plsxax(digmax, digits)\n\
6362 \n\
6363 ARGUMENTS:\n\
6364 \n\
6365  digmax (PLINT, input) : Variable to set the maximum number of\n\
6366  digits for the x axis. If nonzero, the printed label will be\n\
6367  switched to a floating point representation when the number of\n\
6368  digits exceeds digmax. \n\
6369 \n\
6370  digits (PLINT, input) : Field digits value. Currently, changing\n\
6371  its value here has no effect since it is set only by plbox or\n\
6372  plbox3. However, the user may obtain its value after a call to\n\
6373  either of these functions by calling plgxax. \n\
6374 ";
6375 const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
6376 Get viewport limits in world coordinates \n\
6377 \n\
6378 DESCRIPTION:\n\
6379 \n\
6380  Get viewport limits in world coordinates. \n\
6381 \n\
6382  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6383 \t Perl/PDL: Not available? \n\
6384 \n\
6385 \n\
6386  This function is used in example 31. \n\
6387 \n\
6388 \n\
6389 \n\
6390 SYNOPSIS:\n\
6391 \n\
6392 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6393 \n\
6394 ARGUMENTS:\n\
6395 \n\
6396  p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
6397  coordinate in x. \n\
6398 \n\
6399  p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
6400  coordinate in x. \n\
6401 \n\
6402  p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
6403  coordinate in y. \n\
6404 \n\
6405  p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
6406  coordinate in y. \n\
6407 ";
6408 const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
6409 Get current subpage parameters \n\
6410 \n\
6411 DESCRIPTION:\n\
6412 \n\
6413  Gets the size of the current subpage in millimeters measured from the\n\
6414  bottom left hand corner of the output device page or screen. Can be\n\
6415  used in conjunction with plsvpa for setting the size of a viewport in\n\
6416  absolute coordinates (millimeters). \n\
6417 \n\
6418  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
6419 \n\
6420  This function is used in example 23. \n\
6421 \n\
6422 \n\
6423 \n\
6424 SYNOPSIS:\n\
6425 \n\
6426 plgspa(xmin, xmax, ymin, ymax)\n\
6427 \n\
6428 ARGUMENTS:\n\
6429 \n\
6430  xmin (PLFLT *, output) : Pointer to variable with position of left\n\
6431  hand edge of subpage in millimeters. \n\
6432 \n\
6433  xmax (PLFLT *, output) : Pointer to variable with position of right\n\
6434  hand edge of subpage in millimeters. \n\
6435 \n\
6436  ymin (PLFLT *, output) : Pointer to variable with position of\n\
6437  bottom edge of subpage in millimeters. \n\
6438 \n\
6439  ymax (PLFLT *, output) : Pointer to variable with position of top\n\
6440  edge of subpage in millimeters. \n\
6441 ";
6442 const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
6443 Calculate world coordinates and corresponding window index from relative device coordinates \n\
6444 \n\
6445 DESCRIPTION:\n\
6446 \n\
6447  Calculate world coordinates, wx and wy, and corresponding window index\n\
6448  from relative device coordinates, rx and ry. \n\
6449 \n\
6450  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
6451 \t Perl/PDL: Not available? \n\
6452 \n\
6453 \n\
6454  This function is used in example 31. \n\
6455 \n\
6456 \n\
6457 \n\
6458 SYNOPSIS:\n\
6459 \n\
6460 plcalc_world(rx, ry, wx, wy, window)\n\
6461 \n\
6462 ARGUMENTS:\n\
6463 \n\
6464  rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
6465  0. to 1.) for the x coordinate. \n\
6466 \n\
6467  ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
6468  0. to 1.) for the y coordinate. \n\
6469 \n\
6470  wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6471  x corresponding to the relative device coordinates rx and ry. \n\
6472 \n\
6473  wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6474  y corresponding to the relative device coordinates rx and ry. \n\
6475 \n\
6476  window (PLINT *, output) : Pointer to the returned last defined\n\
6477  window index that corresponds to the input relative device\n\
6478  coordinates (and the returned world coordinates). To give some\n\
6479  background on the window index, for each page the initial window\n\
6480  index is set to zero, and each time plwind is called within the\n\
6481  page, world and device coordinates are stored for the window and\n\
6482  the window index is incremented. Thus, for a simple page layout\n\
6483  with non-overlapping viewports and one window per viewport, window\n\
6484  corresponds to the viewport index (in the order which the\n\
6485  viewport/windows were created) of the only viewport/window\n\
6486  corresponding to rx and ry. However, for more complicated layouts\n\
6487  with potentially overlapping viewports and possibly more than one\n\
6488  window (set of world coordinates) per viewport, window and the\n\
6489  corresponding output world coordinates corresponds to the last\n\
6490  window created that fulfills the criterion that the relative\n\
6491  device coordinates are inside it. Finally, in all cases where the\n\
6492  input relative device coordinates are not inside any\n\
6493  viewport/window, then window is set to -1. \n\
6494 ";
6495 const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6496 Draw a box with axes, etc, in 3-d \n\
6497 \n\
6498 DESCRIPTION:\n\
6499 \n\
6500  Draws axes, numeric and text labels for a three-dimensional surface\n\
6501  plot. For a more complete description of three-dimensional plotting\n\
6502  see the PLplot documentation. \n\
6503 \n\
6504  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6505  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6506 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
6507  xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
6508 \n\
6509 \n\
6510  This function is used in examples 8,11,18,21. \n\
6511 \n\
6512 \n\
6513 \n\
6514 SYNOPSIS:\n\
6515 \n\
6516 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6517 \n\
6518 ARGUMENTS:\n\
6519 \n\
6520  xopt (const char *, input) : Pointer to character string specifying\n\
6521  options for the x axis. The string can include any combination of\n\
6522  the following letters (upper or lower case) in any order: b: Draws\n\
6523  axis at base, at height z=\n\
6524  zmin where zmin is defined by call to plw3d. This character must be\n\
6525  specified in order to use any of the other options. \n\
6526  f: Always use fixed point numeric labels. \n\
6527  i: Inverts tick marks, so they are drawn downwards, rather\n\
6528  than upwards. \n\
6529  l: Labels axis logarithmically. This only affects the labels,\n\
6530  not the data, and so it is necessary to compute the logarithms\n\
6531  of data points before passing them to any of the drawing\n\
6532  routines. \n\
6533  n: Writes numeric labels at major tick intervals. \n\
6534  o: Use custom labelling function to generate axis label text. \n\
6535  The custom labelling function can be defined with the\n\
6536  plslabelfunc command. \n\
6537  s: Enables subticks between major ticks, only valid if t is\n\
6538  also specified. \n\
6539  t: Draws major ticks. \n\
6540  u: If this is specified, the text label for the axis is\n\
6541  written under the axis. \n\
6542 \n\
6543 \n\
6544  xlabel (const char *, input) : Pointer to character string\n\
6545  specifying text label for the x axis. It is only drawn if u is in\n\
6546  the xopt string. \n\
6547 \n\
6548  xtick (PLFLT, input) : World coordinate interval between major\n\
6549  ticks on the x axis. If it is set to zero, PLplot automatically\n\
6550  generates a suitable tick interval. \n\
6551 \n\
6552  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6553  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6554  generates a suitable minor tick interval. \n\
6555 \n\
6556  yopt (const char *, input) : Pointer to character string specifying\n\
6557  options for the y axis. The string is interpreted in the same way\n\
6558  as xopt. \n\
6559 \n\
6560  ylabel (const char *, input) : Pointer to character string\n\
6561  specifying text label for the y axis. It is only drawn if u is in\n\
6562  the yopt string. \n\
6563 \n\
6564  ytick (PLFLT, input) : World coordinate interval between major\n\
6565  ticks on the y axis. If it is set to zero, PLplot automatically\n\
6566  generates a suitable tick interval. \n\
6567 \n\
6568  nysub (PLINT, input) : Number of subintervals between major y axis\n\
6569  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6570  generates a suitable minor tick interval. \n\
6571 \n\
6572  zopt (const char *, input) : Pointer to character string specifying\n\
6573  options for the z axis. The string can include any combination of\n\
6574  the following letters (upper or lower case) in any order: b: Draws\n\
6575  z axis to the left of the surface plot. \n\
6576  c: Draws z axis to the right of the surface plot. \n\
6577  d: Draws grid lines parallel to the x-y plane behind the\n\
6578  figure. These lines are not drawn until after plot3d or\n\
6579  plmesh are called because of the need for hidden line removal. \n\
6580  f: Always use fixed point numeric labels. \n\
6581  i: Inverts tick marks, so they are drawn away from the center. \n\
6582  l: Labels axis logarithmically. This only affects the labels,\n\
6583  not the data, and so it is necessary to compute the logarithms\n\
6584  of data points before passing them to any of the drawing\n\
6585  routines. \n\
6586  m: Writes numeric labels at major tick intervals on the\n\
6587  right-hand vertical axis. \n\
6588  n: Writes numeric labels at major tick intervals on the\n\
6589  left-hand vertical axis. \n\
6590  o: Use custom labelling function to generate axis label text. \n\
6591  The custom labelling function can be defined with the\n\
6592  plslabelfunc command. \n\
6593  s: Enables subticks between major ticks, only valid if t is\n\
6594  also specified. \n\
6595  t: Draws major ticks. \n\
6596  u: If this is specified, the text label is written beside the\n\
6597  left-hand axis. \n\
6598  v: If this is specified, the text label is written beside the\n\
6599  right-hand axis. \n\
6600 \n\
6601 \n\
6602  zlabel (const char *, input) : Pointer to character string\n\
6603  specifying text label for the z axis. It is only drawn if u or v\n\
6604  are in the zopt string. \n\
6605 \n\
6606  ztick (PLFLT, input) : World coordinate interval between major\n\
6607  ticks on the z axis. If it is set to zero, PLplot automatically\n\
6608  generates a suitable tick interval. \n\
6609 \n\
6610  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6611  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6612  generates a suitable minor tick interval. \n\
6613 ";
6614 const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
6615 Get character default height and current (scaled) height \n\
6616 \n\
6617 DESCRIPTION:\n\
6618 \n\
6619  Get character default height and current (scaled) height. \n\
6620 \n\
6621  Redacted form: plgchr(p_def, p_ht)\n\
6622 \n\
6623  This function is used in example 23. \n\
6624 \n\
6625 \n\
6626 \n\
6627 SYNOPSIS:\n\
6628 \n\
6629 plgchr(p_def, p_ht)\n\
6630 \n\
6631 ARGUMENTS:\n\
6632 \n\
6633  p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
6634 \n\
6635  p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
6636  height (mm). \n\
6637 ";
6638 const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
6639 Set the escape character for text strings \n\
6640 \n\
6641 DESCRIPTION:\n\
6642 \n\
6643  Set the escape character for text strings.\tFrom C (in contrast to\n\
6644  Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
6645  selected characters are allowed to prevent the user from shooting\n\
6646  himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
6647  with C\'s use of backslash as a character escape). Here are the\n\
6648  allowed escape characters and their corresponding decimal ASCII\n\
6649  values: !, ASCII 33 \n\
6650 \t #, ASCII 35 \n\
6651 \t $, ASCII 36 \n\
6652 \t %, ASCII 37 \n\
6653 \t &, ASCII 38 \n\
6654 \t *, ASCII 42 \n\
6655 \t @, ASCII 64 \n\
6656 \t ^, ASCII 94 \n\
6657 \t ~, ASCII 126 \n\
6658 \n\
6659 \n\
6660  Redacted form: General: plsesc(esc)\n\
6661 \t Perl/PDL: Not available? \n\
6662 \n\
6663 \n\
6664  This function is used in example 29. \n\
6665 \n\
6666 \n\
6667 \n\
6668 SYNOPSIS:\n\
6669 \n\
6670 plsesc(esc)\n\
6671 \n\
6672 ARGUMENTS:\n\
6673 \n\
6674  esc (char, input) : Escape character. \n\
6675 ";
6676 const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
6677 Draw a line between two points, accounting for coordinate transforms. \n\
6678 \n\
6679 DESCRIPTION:\n\
6680 \n\
6681  Joins the point (\n\
6682  x1, \n\
6683  y1) to (\n\
6684  x2, \n\
6685  y2). If a global coordinate transform is defined then the line is\n\
6686  broken in to n segments to approximate the path. If no transform is\n\
6687  defined then this simply acts like a call to pljoin. \n\
6688 \n\
6689  Redacted form: plpath(n,x1,y1,x2,y2)\n\
6690 \n\
6691  This function is used in example 22. \n\
6692 \n\
6693 \n\
6694 \n\
6695 SYNOPSIS:\n\
6696 \n\
6697 plpath(n, x1, y1, x2, y2)\n\
6698 \n\
6699 ARGUMENTS:\n\
6700 \n\
6701  n (PLINT, input) : number of points to use to approximate the path. \n\
6702 \n\
6703  x1 (PLFLT, input) : x coordinate of first point. \n\
6704 \n\
6705  y1 (PLFLT, input) : y coordinate of first point. \n\
6706 \n\
6707  x2 (PLFLT, input) : x coordinate of second point. \n\
6708 \n\
6709  y2 (PLFLT, input) : y coordinate of second point. \n\
6710 ";
6711 const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
6712 Set up standard window and draw box \n\
6713 \n\
6714 DESCRIPTION:\n\
6715 \n\
6716  Sets up plotter environment for simple graphs by calling pladv and\n\
6717  setting up viewport and window to sensible default values.\tplenv\n\
6718  leaves enough room around most graphs for axis labels and a title.\n\
6719  When these defaults are not suitable, use the individual routines\n\
6720  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
6721  defining the window, and plbox for drawing the box. \n\
6722 \n\
6723  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6724 \n\
6725  This function is used in example 1,3,9,13,14,19-22,29. \n\
6726 \n\
6727 \n\
6728 \n\
6729 SYNOPSIS:\n\
6730 \n\
6731 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6732 \n\
6733 ARGUMENTS:\n\
6734 \n\
6735  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
6736  world coordinates). \n\
6737 \n\
6738  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
6739  world coordinates). \n\
6740 \n\
6741  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
6742  coordinates). \n\
6743 \n\
6744  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
6745  coordinates). \n\
6746 \n\
6747  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
6748  scales will not be set, the user must set up the scale before\n\
6749  calling plenv using plsvpa, plvasp or other. \n\
6750  0: the x and y axes are scaled independently to use as much of\n\
6751  the screen as possible. \n\
6752  1: the scales of the x and y axes are made equal. \n\
6753  2: the axis of the x and y axes are made equal, and the plot\n\
6754  box will be square. \n\
6755 \n\
6756 \n\
6757  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
6758  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
6759  -1: draw box only. \n\
6760  0: draw box, ticks, and numeric tick labels. \n\
6761  1: also draw coordinate axes at x=0 and y=0. \n\
6762  2: also draw a grid at major tick positions in both\n\
6763  coordinates. \n\
6764  3: also draw a grid at minor tick positions in both\n\
6765  coordinates. \n\
6766  10: same as 0 except logarithmic x tick marks. (The x data\n\
6767  have to be converted to logarithms separately.) \n\
6768  11: same as 1 except logarithmic x tick marks. (The x data\n\
6769  have to be converted to logarithms separately.) \n\
6770  12: same as 2 except logarithmic x tick marks. (The x data\n\
6771  have to be converted to logarithms separately.) \n\
6772  13: same as 3 except logarithmic x tick marks. (The x data\n\
6773  have to be converted to logarithms separately.) \n\
6774  20: same as 0 except logarithmic y tick marks. (The y data\n\
6775  have to be converted to logarithms separately.) \n\
6776  21: same as 1 except logarithmic y tick marks. (The y data\n\
6777  have to be converted to logarithms separately.) \n\
6778  22: same as 2 except logarithmic y tick marks. (The y data\n\
6779  have to be converted to logarithms separately.) \n\
6780  23: same as 3 except logarithmic y tick marks. (The y data\n\
6781  have to be converted to logarithms separately.) \n\
6782  30: same as 0 except logarithmic x and y tick marks. (The x\n\
6783  and y data have to be converted to logarithms separately.) \n\
6784  31: same as 1 except logarithmic x and y tick marks. (The x\n\
6785  and y data have to be converted to logarithms separately.) \n\
6786  32: same as 2 except logarithmic x and y tick marks. (The x\n\
6787  and y data have to be converted to logarithms separately.) \n\
6788  33: same as 3 except logarithmic x and y tick marks. (The x\n\
6789  and y data have to be converted to logarithms separately.) \n\
6790  40: same as 0 except date / time x labels. \n\
6791  41: same as 1 except date / time x labels. \n\
6792  42: same as 2 except date / time x labels. \n\
6793  43: same as 3 except date / time x labels. \n\
6794  50: same as 0 except date / time y labels. \n\
6795  51: same as 1 except date / time y labels. \n\
6796  52: same as 2 except date / time y labels. \n\
6797  53: same as 3 except date / time y labels. \n\
6798  60: same as 0 except date / time x and y labels. \n\
6799  61: same as 1 except date / time x and y labels. \n\
6800  62: same as 2 except date / time x and y labels. \n\
6801  63: same as 3 except date / time x and y labels. \n\
6802  70: same as 0 except custom x and y labels. \n\
6803  71: same as 1 except custom x and y labels. \n\
6804  72: same as 2 except custom x and y labels. \n\
6805  73: same as 3 except custom x and y labels. \n\
6806 ";
6807 const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
6808 Clear current (sub)page \n\
6809 \n\
6810 DESCRIPTION:\n\
6811 \n\
6812  Clears the current page, effectively erasing everything that have been\n\
6813  drawn. This command only works with interactive drivers; if the\n\
6814  driver does not support this, the page is filled with the background\n\
6815  color in use. If the current page is divided into subpages, only the\n\
6816  current subpage is erased.\tThe nth subpage can be selected with\n\
6817  pladv(n). \n\
6818 \n\
6819  Redacted form: General: plclear()\n\
6820 \t Perl/PDL: Not available? \n\
6821 \n\
6822 \n\
6823  This function is not used in any examples. \n\
6824 \n\
6825 \n\
6826 \n\
6827 SYNOPSIS:\n\
6828 \n\
6829 plclear()\n\
6830 ";
6831 const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
6832 Set color map0 colors by 8-bit RGB values and double alpha value. \n\
6833 \n\
6834 DESCRIPTION:\n\
6835 \n\
6836  Set color map0 colors using 8-bit RGB values (see the PLplot\n\
6837  documentation) and floating point alpha value. This sets the entire\n\
6838  color map -- only as many colors as specified will be allocated. \n\
6839 \n\
6840  This function is used in examples 30. \n\
6841 \n\
6842 \n\
6843 \n\
6844 SYNOPSIS:\n\
6845 \n\
6846 plscmap0a(r, g, b, a, ncol0)\n\
6847 \n\
6848 ARGUMENTS:\n\
6849 \n\
6850  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6851  integers (0-255) representing the degree of red in the color. \n\
6852 \n\
6853  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6854  integers (0-255) representing the degree of green in the color. \n\
6855 \n\
6856  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6857  integers (0-255) representing the degree of blue in the color. \n\
6858 \n\
6859  a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n\
6860  - 1.0) representing the transparency of the color. \n\
6861 \n\
6862  ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n\
6863  arrays. \n\
6864 ";
6865 const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6866 Set a given color from color map0 by 8 bit RGB value \n\
6867 \n\
6868 DESCRIPTION:\n\
6869 \n\
6870  Set a given color by 8-bit RGB value for color map0 (see the PLplot\n\
6871  documentation). Overwrites the previous color value for the given\n\
6872  index and, thus, does not result in any additional allocation of space\n\
6873  for colors. \n\
6874 \n\
6875  Redacted form: plscol0(icol0, r, g, b)\n\
6876 \n\
6877  This function is used in any example 31. \n\
6878 \n\
6879 \n\
6880 \n\
6881 SYNOPSIS:\n\
6882 \n\
6883 plscol0(icol0, r, g, b)\n\
6884 \n\
6885 ARGUMENTS:\n\
6886 \n\
6887  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6888  number of colors (which is set by default, by plscmap0n, or even\n\
6889  by plscmap0). \n\
6890 \n\
6891  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6892  degree of red in the color. \n\
6893 \n\
6894  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6895  degree of green in the color. \n\
6896 \n\
6897  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6898  degree of blue in the color. \n\
6899 ";
6900 const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
6901 Set up transformation from metafile coordinates \n\
6902 \n\
6903 DESCRIPTION:\n\
6904 \n\
6905  Set up transformation from metafile coordinates. The size of the plot\n\
6906  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
6907  general-purpose facility just yet (not sure why the user would need\n\
6908  it, for one). \n\
6909 \n\
6910  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
6911  dimypmm)\n\
6912 \n\
6913  This function is not used in any examples. \n\
6914 \n\
6915 \n\
6916 \n\
6917 SYNOPSIS:\n\
6918 \n\
6919 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
6920 \n\
6921 ARGUMENTS:\n\
6922 \n\
6923  dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
6924 \n\
6925  dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
6926 \n\
6927  dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
6928 \n\
6929  dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
6930 \n\
6931  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6932 \n\
6933  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6934 ";
6935 const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6936 Creates a new stream and makes it the default \n\
6937 \n\
6938 DESCRIPTION:\n\
6939 \n\
6940  Creates a new stream and makes it the default. Differs from using\n\
6941  plsstrm, in that a free stream number is found, and returned.\n\
6942  Unfortunately, I have to start at stream 1 and work upward, since\n\
6943  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6944  that no initial, library-opening call is required.\tSo stream 0 must\n\
6945  be preallocated, and there is no simple way of determining whether it\n\
6946  is already in use or not. \n\
6947 \n\
6948  Redacted form: plmkstrm(p_strm)\n\
6949 \n\
6950  This function is used in examples 1,20. \n\
6951 \n\
6952 \n\
6953 \n\
6954 SYNOPSIS:\n\
6955 \n\
6956 plmkstrm(p_strm)\n\
6957 \n\
6958 ARGUMENTS:\n\
6959 \n\
6960  p_strm (PLINT *, output) : Pointer to stream number of the created\n\
6961  stream. \n\
6962 ";
6963 const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
6964 Get page parameters \n\
6965 \n\
6966 DESCRIPTION:\n\
6967 \n\
6968  Gets the current page configuration. The length and offset values are\n\
6969  expressed in units that are specific to the current driver. For\n\
6970  instance: screen drivers will usually interpret them as number of\n\
6971  pixels, whereas printer drivers will usually use mm. \n\
6972 \n\
6973  Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6974 \n\
6975  This function is used in examples 14 and 31. \n\
6976 \n\
6977 \n\
6978 \n\
6979 SYNOPSIS:\n\
6980 \n\
6981 plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6982 \n\
6983 ARGUMENTS:\n\
6984 \n\
6985  xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
6986 \n\
6987  yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n\
6988 \n\
6989  xleng (PLINT *, output) : Pointer to x page length value. \n\
6990 \n\
6991  yleng (PLINT *, output) : Pointer to y page length value. \n\
6992 \n\
6993  xoff (PLINT *, output) : Pointer to x page offset. \n\
6994 \n\
6995  yoff (PLINT *, output) : Pointer to y page offset. \n\
6996 ";
6997 const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
6998 Set format for date / time labels \n\
6999 \n\
7000 DESCRIPTION:\n\
7001 \n\
7002  Sets the format for date / time labels. To enable date / time format\n\
7003  labels see the options to plbox and plenv.\t\n\
7004 \n\
7005  Redacted form: pltimefmt(fmt)\n\
7006 \n\
7007  This function is used in example 29. \n\
7008 \n\
7009 \n\
7010 \n\
7011 SYNOPSIS:\n\
7012 \n\
7013 pltimefmt(fmt)\n\
7014 \n\
7015 ARGUMENTS:\n\
7016 \n\
7017  fmt (const char *, fmt) : This string is passed directly to the\n\
7018  system strftime. See the system documentation for a full list of\n\
7019  conversion specifications for your system. All conversion\n\
7020  specifications take the form of a \'%\' character followed by\n\
7021  further conversion specification character. All other text is\n\
7022  printed as-is. Common options include: %c: The preferred date and\n\
7023  time representation for the current locale. \n\
7024  %d: The day of the month as a decimal number. \n\
7025  %H: The hour as a decimal number using a 24-hour clock. \n\
7026  %j: The day of the year as a decimal number. \n\
7027  %m: The month as a decimal number. \n\
7028  %M: The minute as a decimal number. \n\
7029  %S: The second as a decimal number. \n\
7030  %y: The year as a decimal number without a century. \n\
7031  %Y: The year as a decimal number including a century. \n\
7032 ";
7033 const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
7034 Specify viewport using aspect ratio only \n\
7035 \n\
7036 DESCRIPTION:\n\
7037 \n\
7038  Sets the viewport so that the ratio of the length of the y axis to\n\
7039  that of the x axis is equal to aspect. \n\
7040 \n\
7041  Redacted form: plvasp(aspect)\n\
7042 \n\
7043  This function is used in example 13. \n\
7044 \n\
7045 \n\
7046 \n\
7047 SYNOPSIS:\n\
7048 \n\
7049 plvasp(aspect)\n\
7050 \n\
7051 ARGUMENTS:\n\
7052 \n\
7053  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
7054  axis. \n\
7055 ";
7056 const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
7057 Set output file name \n\
7058 \n\
7059 DESCRIPTION:\n\
7060 \n\
7061  Sets the current output file name, if applicable. If the file name\n\
7062  has not been specified and is required by the driver, the user will be\n\
7063  prompted for it. If using the X-windows output driver, this sets the\n\
7064  display name. This routine, if used, must be called before\n\
7065  initializing PLplot. \n\
7066 \n\
7067  Redacted form: plsfnam(fnam)\n\
7068 \n\
7069  This function is used in examples 1,20. \n\
7070 \n\
7071 \n\
7072 \n\
7073 SYNOPSIS:\n\
7074 \n\
7075 plsfnam(fnam)\n\
7076 \n\
7077 ARGUMENTS:\n\
7078 \n\
7079  fnam (const char *, input) : Pointer to file name string. \n\
7080 ";
7081 const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
7082 Set parameters that define current plot-space window \n\
7083 \n\
7084 DESCRIPTION:\n\
7085 \n\
7086  Set relative minima and maxima that define the current plot-space\n\
7087  window. If plsdiplt is not called the default values of xmin, ymin,\n\
7088  xmax, and ymax are 0., 0., 1., and 1. \n\
7089 \n\
7090  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
7091 \n\
7092  This function is used in example 31. \n\
7093 \n\
7094 \n\
7095 \n\
7096 SYNOPSIS:\n\
7097 \n\
7098 plsdiplt(xmin, ymin, xmax, ymax)\n\
7099 \n\
7100 ARGUMENTS:\n\
7101 \n\
7102  xmin (PLFLT, input) : Relative minimum in x. \n\
7103 \n\
7104  ymin (PLFLT, input) : Relative minimum in y. \n\
7105 \n\
7106  xmax (PLFLT, input) : Relative maximum in x. \n\
7107 \n\
7108  ymax (PLFLT, input) : Relative maximum in y. \n\
7109 ";
7110 const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7111 Select line style \n\
7112 \n\
7113 DESCRIPTION:\n\
7114 \n\
7115  This sets the line style according to one of eight predefined patterns\n\
7116  (also see plstyl). \n\
7117 \n\
7118  Redacted form: pllsty(n)\n\
7119 \n\
7120  This function is used in examples 9,12,22,25. \n\
7121 \n\
7122 \n\
7123 \n\
7124 SYNOPSIS:\n\
7125 \n\
7126 pllsty(n)\n\
7127 \n\
7128 ARGUMENTS:\n\
7129 \n\
7130  n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n\
7131  continuous line, line style 2 is a line with short dashes and\n\
7132  gaps, line style 3 is a line with long dashes and gaps, line style\n\
7133  4 has long dashes and short gaps and so on. \n\
7134 ";
7135 const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
7136 Plot a glyph at the specified points \n\
7137 \n\
7138 DESCRIPTION:\n\
7139 \n\
7140  Plot a glyph at the specified points. (This function is largely\n\
7141  superseded by plstring which gives access to many[!] more glyphs.) \n\
7142 \n\
7143  Redacted form: plsym(x, y, code)\n\
7144 \n\
7145  This function is used in example 7. \n\
7146 \n\
7147 \n\
7148 \n\
7149 SYNOPSIS:\n\
7150 \n\
7151 plsym(n, x, y, code)\n\
7152 \n\
7153 ARGUMENTS:\n\
7154 \n\
7155  n (PLINT, input) : Number of points in the x and y arrays. \n\
7156 \n\
7157  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7158  points. \n\
7159 \n\
7160  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7161  points. \n\
7162 \n\
7163  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
7164  to be plotted at each of the n points. \n\
7165 ";
7166 const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7167 Set the device (keyword) name \n\
7168 \n\
7169 DESCRIPTION:\n\
7170 \n\
7171  Set the device (keyword) name. \n\
7172 \n\
7173  Redacted form: plsdev(devname)\n\
7174 \n\
7175  This function is used in examples 1,14,20. \n\
7176 \n\
7177 \n\
7178 \n\
7179 SYNOPSIS:\n\
7180 \n\
7181 plsdev(devname)\n\
7182 \n\
7183 ARGUMENTS:\n\
7184 \n\
7185  devname (const char *, input) : Pointer to device (keyword) name\n\
7186  string. \n\
7187 ";
7188 const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
7189 Set the background color by 8-bit RGB value \n\
7190 \n\
7191 DESCRIPTION:\n\
7192 \n\
7193  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7194  (see the PLplot documentation). \n\
7195 \n\
7196  Redacted form: plscolbg(r, g, b)\n\
7197 \n\
7198  This function is used in examples 15,31. \n\
7199 \n\
7200 \n\
7201 \n\
7202 SYNOPSIS:\n\
7203 \n\
7204 plscolbg(r, g, b)\n\
7205 \n\
7206 ARGUMENTS:\n\
7207 \n\
7208  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7209  degree of red in the color. \n\
7210 \n\
7211  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7212  degree of green in the color. \n\
7213 \n\
7214  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7215  degree of blue in the color. \n\
7216 ";
7217 const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
7218 Set parameters incrementally (zoom mode) that define current plot-space window \n\
7219 \n\
7220 DESCRIPTION:\n\
7221 \n\
7222  Set relative minima and maxima incrementally (zoom mode) that define\n\
7223  the current plot-space window. This function has the same effect as\n\
7224  plsdiplt if that function has not been previously called. Otherwise,\n\
7225  this function implements zoom mode using the transformation min_used =\n\
7226  old_min + old_length*min and max_used = old_min + old_length*max for\n\
7227  each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
7228  repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
7229 \n\
7230  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
7231 \n\
7232  This function is used in example 31. \n\
7233 \n\
7234 \n\
7235 \n\
7236 SYNOPSIS:\n\
7237 \n\
7238 plsdiplz(xmin, ymin, xmax, ymax)\n\
7239 \n\
7240 ARGUMENTS:\n\
7241 \n\
7242  xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
7243 \n\
7244  ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
7245 \n\
7246  xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
7247 \n\
7248  ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
7249 ";
7250 const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
7251 Advance to the next family file on the next new page \n\
7252 \n\
7253 DESCRIPTION:\n\
7254 \n\
7255  Advance to the next family file on the next new page. \n\
7256 \n\
7257  Redacted form: plfamadv()\n\
7258 \n\
7259  This function is not used in any examples. \n\
7260 \n\
7261 \n\
7262 \n\
7263 SYNOPSIS:\n\
7264 \n\
7265 plfamadv()\n\
7266 ";
7267 const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
7268 Set number of colors in color map0 \n\
7269 \n\
7270 DESCRIPTION:\n\
7271 \n\
7272  Set number of colors in color map0 (see the PLplot documentation).\n\
7273  Allocate (or reallocate) color map0, and fill with default values for\n\
7274  those colors not previously allocated. The first 16 default colors are\n\
7275  given in the plcol0 documentation. For larger indices the default\n\
7276  color is red. \n\
7277 \n\
7278  The drivers are not guaranteed to support more than 16 colors. \n\
7279 \n\
7280  Redacted form: plscmap0n(ncol0)\n\
7281 \n\
7282  This function is used in examples 15,16,24. \n\
7283 \n\
7284 \n\
7285 \n\
7286 SYNOPSIS:\n\
7287 \n\
7288 plscmap0n(ncol0)\n\
7289 \n\
7290 ARGUMENTS:\n\
7291 \n\
7292  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
7293  the map0 palette. If this number is zero or less, then the value\n\
7294  from the previous call to plscmap0n is used and if there is no\n\
7295  previous call, then a default value is used. \n\
7296 ";
7297 const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
7298 Plot latitude and longitude lines. \n\
7299 \n\
7300 DESCRIPTION:\n\
7301 \n\
7302  Displays latitude and longitude on the current plot. The lines are\n\
7303  plotted in the current color and line style. \n\
7304 \n\
7305  Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n\
7306  maxlong, minlat, maxlat)\n\
7307 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
7308 \n\
7309 \n\
7310  This function is used in example 19. \n\
7311 \n\
7312 \n\
7313 \n\
7314 SYNOPSIS:\n\
7315 \n\
7316 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7317 \n\
7318 ARGUMENTS:\n\
7319 \n\
7320  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
7321  supplied function to transform the coordinate longitudes and\n\
7322  latitudes to a plot coordinate system. By using this transform,\n\
7323  we can change from a longitude, latitude coordinate to a polar\n\
7324  stereographic project, for example. Initially, x[0]..[n-1] are\n\
7325  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
7326  After the call to mapform(), x[] and y[] should be replaced by\n\
7327  the corresponding plot coordinates. If no transform is desired,\n\
7328  mapform can be replaced by NULL. \n\
7329 \n\
7330  dlong (PLFLT, input) : The interval in degrees at which the\n\
7331  longitude lines are to be plotted. \n\
7332 \n\
7333  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7334  lines are to be plotted. \n\
7335 \n\
7336  minlong (PLFLT, input) : The value of the longitude on the left\n\
7337  side of the plot. The value of minlong must be less than the\n\
7338  value of maxlong, and the quantity maxlong-minlong must be less\n\
7339  than or equal to 360. \n\
7340 \n\
7341  maxlong (PLFLT, input) : The value of the longitude on the right\n\
7342  side of the plot. \n\
7343 \n\
7344  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7345  background. One can always use -90.0 as the boundary outside the\n\
7346  plot window will be automatically eliminated. However, the\n\
7347  program will be faster if one can reduce the size of the\n\
7348  background plotted. \n\
7349 \n\
7350  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7351  background. One can always use 90.0 as the boundary outside the\n\
7352  plot window will be automatically eliminated. \n\
7353 ";
7354 const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
7355 Convert RGB color to HLS \n\
7356 \n\
7357 DESCRIPTION:\n\
7358 \n\
7359  Convert RGB color coordinates to HLS \n\
7360 \n\
7361  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7362 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
7363 \n\
7364 \n\
7365  This function is used in example 2. \n\
7366 \n\
7367 \n\
7368 \n\
7369 SYNOPSIS:\n\
7370 \n\
7371 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7372 \n\
7373 ARGUMENTS:\n\
7374 \n\
7375  r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
7376 \n\
7377  g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
7378 \n\
7379  b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
7380 \n\
7381  p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
7382  cone (0.0-360.0) \n\
7383 \n\
7384  p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
7385  fraction of the axis of the colour cone (0.0-1.0) \n\
7386 \n\
7387  p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
7388  fraction of the radius of the colour cone (0.0-1.0) \n\
7389 ";
7390 const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
7391 Plot a glyph at the specified 3D points \n\
7392 \n\
7393 DESCRIPTION:\n\
7394 \n\
7395  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
7396  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
7397  this function similar to what is done for plline3. The glyph is\n\
7398  specified with a PLplot user string. Note that the user string is not\n\
7399  actually limited to one glyph so it is possible (but not normally\n\
7400  useful) to plot more than one glyph at the specified points with this\n\
7401  function. As with plmtex and plptex, the user string can contain FCI\n\
7402  escapes to determine the font, UTF-8 code to determine the glyph or\n\
7403  else PLplot escapes for Hershey or unicode text to determine the\n\
7404  glyph. \n\
7405 \n\
7406  Redacted form: plstring3(x, y, z, string)\n\
7407 \n\
7408  This function is used in example 18. \n\
7409 \n\
7410 \n\
7411 \n\
7412 SYNOPSIS:\n\
7413 \n\
7414 plstring3(n, x, y, z, string)\n\
7415 \n\
7416 ARGUMENTS:\n\
7417 \n\
7418  n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
7419 \n\
7420  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7421  points. \n\
7422 \n\
7423  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7424  points. \n\
7425 \n\
7426  z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7427  points. \n\
7428 \n\
7429  string (const char *, input) : PLplot user string corresponding to\n\
7430  the glyph to be plotted at each of the n points. \n\
7431 ";
7432 const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7433 Switch to text screen \n\
7434 \n\
7435 DESCRIPTION:\n\
7436 \n\
7437  Sets an interactive device to text mode, used in conjunction with\n\
7438  plgra to allow graphics and text to be interspersed. On a device\n\
7439  which supports separate text and graphics windows, this command causes\n\
7440  control to be switched to the text window.\tThis can be useful for\n\
7441  printing diagnostic messages or getting user input, which would\n\
7442  otherwise interfere with the plots. The program must switch back to\n\
7443  the graphics window before issuing plot commands, as the text (or\n\
7444  console) device will probably become quite confused otherwise. If\n\
7445  already in text mode, this command is ignored. It is also ignored on\n\
7446  devices which only support a single window or use a different method\n\
7447  for shifting focus (see also plgra). \n\
7448 \n\
7449  Redacted form: pltext()\n\
7450 \n\
7451  This function is used in example 1. \n\
7452 \n\
7453 \n\
7454 \n\
7455 SYNOPSIS:\n\
7456 \n\
7457 pltext()\n\
7458 ";
7459 const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
7460 Get parameters that define current plot-space window \n\
7461 \n\
7462 DESCRIPTION:\n\
7463 \n\
7464  Get relative minima and maxima that define current plot-space window.\n\
7465  If plsdiplt has not been called the default values pointed to by\n\
7466  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
7467 \n\
7468  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7469 \n\
7470  This function is used in example 31. \n\
7471 \n\
7472 \n\
7473 \n\
7474 SYNOPSIS:\n\
7475 \n\
7476 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7477 \n\
7478 ARGUMENTS:\n\
7479 \n\
7480  p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
7481 \n\
7482  p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
7483 \n\
7484  p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
7485 \n\
7486  p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
7487 ";
7488 const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7489 Get the (current) run level \n\
7490 \n\
7491 DESCRIPTION:\n\
7492 \n\
7493  Get the (current) run level. Valid settings are: 0, uninitialized \n\
7494 \t 1,\tinitialized \n\
7495 \t 2,\tviewport defined \n\
7496 \t 3,\tworld coordinates defined \n\
7497 \n\
7498 \n\
7499  Redacted form: plglevel(p_level)\n\
7500 \n\
7501  This function is used in example 31. \n\
7502 \n\
7503 \n\
7504 \n\
7505 SYNOPSIS:\n\
7506 \n\
7507 plglevel(p_level)\n\
7508 \n\
7509 ARGUMENTS:\n\
7510 \n\
7511  p_level (PLINT *, output) : Pointer to the run level. \n\
7512 ";
7513 const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
7514 Plot a histogram from binned data \n\
7515 \n\
7516 DESCRIPTION:\n\
7517 \n\
7518  Plots a histogram consisting of nbin bins.\tThe value associated with\n\
7519  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
7520  placed in y[i]. For proper operation, the values in x[i] must form a\n\
7521  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
7522  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
7523  placed midway between the values in the x array. Also see plhist for\n\
7524  drawing histograms from unbinned data. \n\
7525 \n\
7526  Redacted form: General: plbin(x, y, opt)\n\
7527 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
7528 \t Python: plbin(nbin, x, y, opt)\n\
7529 \n\
7530 \n\
7531  This function is not used in any examples. \n\
7532 \n\
7533 \n\
7534 \n\
7535 SYNOPSIS:\n\
7536 \n\
7537 plbin(nbin, x, y, opt)\n\
7538 \n\
7539 ARGUMENTS:\n\
7540 \n\
7541  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
7542  and y arrays.) \n\
7543 \n\
7544  x (PLFLT *, input) : Pointer to array containing values associated\n\
7545  with bins. These must form a strictly increasing sequence. \n\
7546 \n\
7547  y (PLFLT *, input) : Pointer to array containing number of points\n\
7548  in bin. This is a PLFLT (instead of PLINT) array so as to allow\n\
7549  histograms of probabilities, etc. \n\
7550 \n\
7551  opt (PLINT, input) : Is a combination of several flags:\n\
7552  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
7553  outer bins are expanded to fill up the entire x-axis and bins of\n\
7554  zero height are simply drawn. \n\
7555  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
7556  between the x values. If the values in x are equally spaced,\n\
7557  the values are the center values of the bins. \n\
7558  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
7559  size as the ones inside. \n\
7560  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
7561  (there is a gap for such bins). \n\
7562 ";
7563 const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7564 Get family, style and weight of the current font \n\
7565 \n\
7566 DESCRIPTION:\n\
7567 \n\
7568  Gets information about current font. See the PLplot documentation for\n\
7569  more information on font selection. \n\
7570 \n\
7571  Redacted form: plgfont(p_family, p_style, p_weight)\n\
7572 \n\
7573  This function is used in example 23. \n\
7574 \n\
7575 \n\
7576 \n\
7577 SYNOPSIS:\n\
7578 \n\
7579 plgfont(p_family, p_style, p_weight)\n\
7580 \n\
7581 ARGUMENTS:\n\
7582 \n\
7583  p_family (PLINT *, output) : Pointer to variable with the current\n\
7584  font family. The available values are given by the PL_FCI_*\n\
7585  constants in plplot.h. Current options are PL_FCI_SANS,\n\
7586  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7587  p_family is NULL then the font family is not returned. \n\
7588 \n\
7589  p_style (PLINT *, output) : Pointer to variable with the current\n\
7590  font style. The available values are given by the PL_FCI_*\n\
7591  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7592  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
7593  font style is not returned. \n\
7594 \n\
7595  p_weight (PLINT *, output) : Pointer to variable with the current\n\
7596  font weight. The available values are given by the PL_FCI_*\n\
7597  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7598  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7599  returned. \n\
7600 ";
7601 const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
7602 Get z axis parameters \n\
7603 \n\
7604 DESCRIPTION:\n\
7605 \n\
7606  Identical to plgxax, except that arguments are flags for z axis. See\n\
7607  the description of plgxax for more detail. \n\
7608 \n\
7609  Redacted form: plgzax(digmax, digits)\n\
7610 \n\
7611  This function is used in example 31. \n\
7612 \n\
7613 \n\
7614 \n\
7615 SYNOPSIS:\n\
7616 \n\
7617 plgzax(digmax, digits)\n\
7618 \n\
7619 ARGUMENTS:\n\
7620 \n\
7621  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7622  number of digits for the z axis. If nonzero, the printed label\n\
7623  has been switched to a floating point representation when the\n\
7624  number of digits exceeds digmax. \n\
7625 \n\
7626  digits (PLINT *, output) : Pointer to variable with the actual\n\
7627  number of digits for the numeric labels (z axis) from the last\n\
7628  plot. \n\
7629 ";
7630 const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
7631 Write text inside the viewport of a 3D plot. \n\
7632 \n\
7633 DESCRIPTION:\n\
7634 \n\
7635  Writes text at a specified position and inclination and with a\n\
7636  specified shear within the viewport. Text is clipped at the viewport\n\
7637  boundaries. The reference point of a string lies along a line passing\n\
7638  through the string at half the height of a capital letter.\tThe\n\
7639  position of the reference point along this line is determined by just,\n\
7640  and the reference point is placed at world coordinates (\n\
7641  x, \n\
7642  y, \n\
7643  z) within the viewport. The inclination and shear of the string is\n\
7644  specified in terms of differences of world coordinates making it easy\n\
7645  to write text parallel to a line in a graph. \n\
7646 \n\
7647  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7648 \n\
7649  This function is used in example 28. \n\
7650 \n\
7651 \n\
7652 \n\
7653 SYNOPSIS:\n\
7654 \n\
7655 plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7656 \n\
7657 ARGUMENTS:\n\
7658 \n\
7659  x (PLFLT, input) : x coordinate of reference point of string. \n\
7660 \n\
7661  y (PLFLT, input) : y coordinate of reference point of string. \n\
7662 \n\
7663  z (PLFLT, input) : z coordinate of reference point of string. \n\
7664 \n\
7665  dx (PLFLT, input) : Together with dy and \n\
7666  dz, this specifies the inclination of the string. The baseline of\n\
7667  the string is parallel to a line joining (\n\
7668  x, \n\
7669  y, \n\
7670  z) to (\n\
7671  x+\n\
7672  dx, \n\
7673  y+\n\
7674  dy, \n\
7675  z+\n\
7676  dz). \n\
7677 \n\
7678  dy (PLFLT, input) : Together with dx and \n\
7679  dz, this specifies the inclination of the string. \n\
7680 \n\
7681  dz (PLFLT, input) : Together with dx and \n\
7682  dy, this specifies the inclination of the string. \n\
7683 \n\
7684  sx (PLFLT, input) : Together with sy and \n\
7685  sz, this specifies the shear of the string. The string is sheared so\n\
7686  that the characters are vertically parallel to a line joining (\n\
7687  x, \n\
7688  y, \n\
7689  z) to (\n\
7690  x+\n\
7691  sx, \n\
7692  y+\n\
7693  sy, \n\
7694  z+\n\
7695  sz). If sx = \n\
7696  sy = \n\
7697  sz = 0.) then the text is not sheared. \n\
7698 \n\
7699  sy (PLFLT, input) : Together with sx and \n\
7700  sz, this specifies shear of the string. \n\
7701 \n\
7702  sz (PLFLT, input) : Together with sx and \n\
7703  sy, this specifies shear of the string. \n\
7704 \n\
7705  just (PLFLT, input) : Specifies the position of the string relative\n\
7706  to its reference point. If just=0., the reference point is at the\n\
7707  left and if just=1., it is at the right of the string. Other\n\
7708  values of just give intermediate justifications. \n\
7709 \n\
7710  text (const char *, input) : The string to be written out. \n\
7711 ";
7712 const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
7713 Draw a box with axes, etc. with arbitrary origin \n\
7714 \n\
7715 DESCRIPTION:\n\
7716 \n\
7717  Draws a box around the currently defined viewport with arbitrary\n\
7718  world-coordinate origin specified by x0 and y0 and labels it with\n\
7719  world coordinate values appropriate to the window.\tThus plaxes should\n\
7720  only be called after defining both viewport and window. The character\n\
7721  strings xopt and yopt specify how the box should be drawn as described\n\
7722  below. If ticks and/or subticks are to be drawn for a particular\n\
7723  axis, the tick intervals and number of subintervals may be specified\n\
7724  explicitly, or they may be defaulted by setting the appropriate\n\
7725  arguments to zero. \n\
7726 \n\
7727  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
7728  ytick, nysub)\n\
7729 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
7730  yopt)\n\
7731 \n\
7732 \n\
7733  This function is not used in any examples. \n\
7734 \n\
7735 \n\
7736 \n\
7737 SYNOPSIS:\n\
7738 \n\
7739 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
7740 \n\
7741 ARGUMENTS:\n\
7742 \n\
7743  x0 (PLFLT, input) : World X coordinate of origin. \n\
7744 \n\
7745  y0 (PLFLT, input) : World Y coordinate of origin. \n\
7746 \n\
7747  xopt (const char *, input) : Pointer to character string specifying\n\
7748  options for horizontal axis. The string can include any\n\
7749  combination of the following letters (upper or lower case) in any\n\
7750  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
7751  is vertical line (x=0). \n\
7752  b: Draws bottom (X) or left (Y) edge of frame. \n\
7753  c: Draws top (X) or right (Y) edge of frame. \n\
7754  d: Plot labels as date / time. Values are assumed to be\n\
7755  seconds since the epoch (as used by gmtime). \n\
7756  f: Always use fixed point numeric labels. \n\
7757  g: Draws a grid at the major tick interval. \n\
7758  h: Draws a grid at the minor tick interval. \n\
7759  i: Inverts tick marks, so they are drawn outwards, rather than\n\
7760  inwards. \n\
7761  l: Labels axis logarithmically. This only affects the labels,\n\
7762  not the data, and so it is necessary to compute the logarithms\n\
7763  of data points before passing them to any of the drawing\n\
7764  routines. \n\
7765  m: Writes numeric labels at major tick intervals in the\n\
7766  unconventional location (above box for X, right of box for Y). \n\
7767  n: Writes numeric labels at major tick intervals in the\n\
7768  conventional location (below box for X, left of box for Y). \n\
7769  o: Use custom labelling function to generate axis label text. \n\
7770  The custom labelling function can be defined with the\n\
7771  plslabelfunc command. \n\
7772  s: Enables subticks between major ticks, only valid if t is\n\
7773  also specified. \n\
7774  t: Draws major ticks. \n\
7775  u: Exactly like \"b\" except don\'t draw edge line. \n\
7776  w: Exactly like \"c\" except don\'t draw edge line. \n\
7777  x: Exactly like \"t\" (including the side effect of the\n\
7778  numerical labels for the major ticks) except exclude drawing\n\
7779  the major and minor tick marks. \n\
7780 \n\
7781 \n\
7782  xtick (PLFLT, input) : World coordinate interval between major\n\
7783  ticks on the x axis. If it is set to zero, PLplot automatically\n\
7784  generates a suitable tick interval. \n\
7785 \n\
7786  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
7787  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7788  generates a suitable minor tick interval. \n\
7789 \n\
7790  yopt (const char *, input) : Pointer to character string specifying\n\
7791  options for vertical axis. The string can include any combination\n\
7792  of the letters defined above for xopt, and in addition may\n\
7793  contain: v: Write numeric labels for vertical axis parallel to the\n\
7794  base of the graph, rather than parallel to the axis. \n\
7795 \n\
7796 \n\
7797  ytick (PLFLT, input) : World coordinate interval between major\n\
7798  ticks on the y axis. If it is set to zero, PLplot automatically\n\
7799  generates a suitable tick interval. \n\
7800 \n\
7801  nysub (PLINT, input) : Number of subintervals between major y axis\n\
7802  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7803  generates a suitable minor tick interval. \n\
7804 ";
7805 const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
7806 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
7807 \n\
7808 DESCRIPTION:\n\
7809 \n\
7810  Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
7811 \n\
7812  Redacted form: plgcolbg(r, g, b)\n\
7813 \n\
7814  This function is used in example 31. \n\
7815 \n\
7816 \n\
7817 \n\
7818 SYNOPSIS:\n\
7819 \n\
7820 plgcolbg(r, g, b)\n\
7821 \n\
7822 ARGUMENTS:\n\
7823 \n\
7824  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7825  representing the degree of red in the color. \n\
7826 \n\
7827  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7828  representing the degree of green in the color. \n\
7829 \n\
7830  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7831  representing the degree of blue in the color. \n\
7832 ";
7833 const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
7834 Plot a glyph at the specified 3D points \n\
7835 \n\
7836 DESCRIPTION:\n\
7837 \n\
7838  Plot a glyph at the specified 3D points. (This function is largely\n\
7839  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
7840  Set up the call to this function similar to what is done for plline3.\n\
7841  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7842  and a draw at the same place. Not ideal, since a sufficiently\n\
7843  intelligent output device may optimize it away, or there may be faster\n\
7844  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7845  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7846  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7847  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7848  code <= 127 the corresponding printable ASCII character is plotted. \n\
7849 \n\
7850  Redacted form: plpoin3(x, y, z, code)\n\
7851 \n\
7852  This function is not used in any example. \n\
7853 \n\
7854 \n\
7855 \n\
7856 SYNOPSIS:\n\
7857 \n\
7858 plpoin3(n, x, y, z, code)\n\
7859 \n\
7860 ARGUMENTS:\n\
7861 \n\
7862  n (PLINT, input) : Number of points in the x and y arrays. \n\
7863 \n\
7864  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7865  points. \n\
7866 \n\
7867  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7868  points. \n\
7869 \n\
7870  z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7871  points. \n\
7872 \n\
7873  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7874  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7875  each of the n points. \n\
7876 ";
7877 const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
7878 Draw a polygon in 3 space \n\
7879 \n\
7880 DESCRIPTION:\n\
7881 \n\
7882  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
7883  like plline3, but differs from that function in that plpoly3 attempts\n\
7884  to determine if the polygon is viewable depending on the order of the\n\
7885  points within the arrays and the value of ifcc. If the back of\n\
7886  polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
7887  you want, then use plline3 instead. \n\
7888 \n\
7889  The points are assumed to be in a plane, and the directionality of the\n\
7890  plane is determined from the first three points. Additional points do\n\
7891  not have to lie on the plane defined by the first three, but if they\n\
7892  do not, then the determination of visibility obviously can\'t be 100%\n\
7893  accurate... So if you\'re 3 space polygons are too far from planar,\n\
7894  consider breaking them into smaller polygons. 3 points define a plane\n\
7895  :-). \n\
7896 \n\
7897  Bugs: If one of the first two segments is of zero length, or if they\n\
7898  are co-linear, the calculation of visibility has a 50/50 chance of\n\
7899  being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
7900  of this problem. (Search for 20.1). \n\
7901 \n\
7902  Redacted form: plpoly3(x, y, z, code)\n\
7903 \n\
7904  This function is used in example 18. \n\
7905 \n\
7906 \n\
7907 \n\
7908 SYNOPSIS:\n\
7909 \n\
7910 plpoly3(n, x, y, z, draw, ifcc)\n\
7911 \n\
7912 ARGUMENTS:\n\
7913 \n\
7914  n (PLINT, input) : Number of points defining line. \n\
7915 \n\
7916  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
7917 \n\
7918  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
7919 \n\
7920  z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
7921 \n\
7922  draw (PLBOOL *, input) : Pointer to array which controls drawing\n\
7923  the segments of the polygon. If draw[i] is true, then the polygon\n\
7924  segment from index [i] to [i+1] is drawn, otherwise, not. \n\
7925 \n\
7926  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
7927  polygon is determined by assuming the points are laid out in a\n\
7928  counter-clockwise order. Otherwise, the directionality of the\n\
7929  polygon is determined by assuming the points are laid out in a\n\
7930  clockwise order. \n\
7931 ";
7932 const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
7933 Set the background color by 8-bit RGB value and double alpha value. \n\
7934 \n\
7935 DESCRIPTION:\n\
7936 \n\
7937  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7938  (see the PLplot documentation) and double alpha value. \n\
7939 \n\
7940  This function is used in example 31. \n\
7941 \n\
7942 \n\
7943 \n\
7944 SYNOPSIS:\n\
7945 \n\
7946 plscolbga(r, g, b, a)\n\
7947 \n\
7948 ARGUMENTS:\n\
7949 \n\
7950  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7951  degree of red in the color. \n\
7952 \n\
7953  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7954  degree of green in the color. \n\
7955 \n\
7956  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7957  degree of blue in the color. \n\
7958 \n\
7959  a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
7960  value of the color. \n\
7961 ";
7962 const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7963 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n\
7964 \n\
7965 DESCRIPTION:\n\
7966 \n\
7967  Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
7968  alpha value. \n\
7969 \n\
7970  This function is used in example 31. \n\
7971 \n\
7972 \n\
7973 \n\
7974 SYNOPSIS:\n\
7975 \n\
7976 plgcolbga(r, g, b, a)\n\
7977 \n\
7978 ARGUMENTS:\n\
7979 \n\
7980  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7981  representing the degree of red in the color. \n\
7982 \n\
7983  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7984  representing the degree of green in the color. \n\
7985 \n\
7986  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7987  representing the degree of blue in the color. \n\
7988 \n\
7989  a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
7990 ";
7991 const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
7992 Draw x error bar \n\
7993 \n\
7994 DESCRIPTION:\n\
7995 \n\
7996  Draws a set of n horizontal error bars, the i\'th error bar extending\n\
7997  from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
7998  error bar are of length equal to the minor tick length (settable using\n\
7999  plsmin). \n\
8000 \n\
8001  Redacted form: General: plerrx(xmin, ymax, y)\n\
8002 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
8003 \n\
8004 \n\
8005  This function is used in example 29. \n\
8006 \n\
8007 \n\
8008 \n\
8009 SYNOPSIS:\n\
8010 \n\
8011 plerrx(n, xmin, xmax, y)\n\
8012 \n\
8013 ARGUMENTS:\n\
8014 \n\
8015  n (PLINT, input) : Number of error bars to draw. \n\
8016 \n\
8017  xmin (PLFLT *, input) : Pointer to array with x coordinates of\n\
8018  left-hand endpoint of error bars. \n\
8019 \n\
8020  xmax (PLFLT *, input) : Pointer to array with x coordinates of\n\
8021  right-hand endpoint of error bars. \n\
8022 \n\
8023  y (PLFLT *, input) : Pointer to array with y coordinates of error\n\
8024  bar. \n\
8025 ";
8026 const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8027 Eject current page \n\
8028 \n\
8029 DESCRIPTION:\n\
8030 \n\
8031  Clears the graphics screen of an interactive device, or ejects a page\n\
8032  on a plotter. See plbop for more information. \n\
8033 \n\
8034  Redacted form: pleop()\n\
8035 \n\
8036  This function is used in example 2,14. \n\
8037 \n\
8038 \n\
8039 \n\
8040 SYNOPSIS:\n\
8041 \n\
8042 pleop()\n\
8043 ";
8044 const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
8045 Convert HLS color to RGB \n\
8046 \n\
8047 DESCRIPTION:\n\
8048 \n\
8049  Convert HLS color coordinates to RGB. \n\
8050 \n\
8051  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8052 \t Perl/PDL: Not available? Implemented as plhls? \n\
8053 \n\
8054 \n\
8055  This function is used in example 2. \n\
8056 \n\
8057 \n\
8058 \n\
8059 SYNOPSIS:\n\
8060 \n\
8061 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8062 \n\
8063 ARGUMENTS:\n\
8064 \n\
8065  h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
8066 \n\
8067  l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
8068  of the colour cone (0.0-1.0) \n\
8069 \n\
8070  s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
8071  radius of the colour cone (0.0-1.0) \n\
8072 \n\
8073  p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
8074  colour \n\
8075 \n\
8076  p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
8077  colour \n\
8078 \n\
8079  p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
8080  colour \n\
8081 ";
8082 const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
8083 Draw y error bar \n\
8084 \n\
8085 DESCRIPTION:\n\
8086 \n\
8087  Draws a set of n vertical error bars, the i\'th error bar extending\n\
8088  from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
8089  error bar are of length equal to the minor tick length (settable using\n\
8090  plsmin). \n\
8091 \n\
8092  Redacted form: General: plerry(x, ymin, ymax)\n\
8093 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
8094 \n\
8095 \n\
8096  This function is used in example 29. \n\
8097 \n\
8098 \n\
8099 \n\
8100 SYNOPSIS:\n\
8101 \n\
8102 plerry(n, x, ymin, ymax)\n\
8103 \n\
8104 ARGUMENTS:\n\
8105 \n\
8106  n (PLINT, input) : Number of error bars to draw. \n\
8107 \n\
8108  x (PLFLT *, input) : Pointer to array with x coordinates of error\n\
8109  bars. \n\
8110 \n\
8111  ymin (PLFLT *, input) : Pointer to array with y coordinates of\n\
8112  lower endpoint of error bars. \n\
8113 \n\
8114  ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n\
8115  endpoint of error bar. \n\
8116 ";
8117 const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
8118 Set FCI (font characterization integer) \n\
8119 \n\
8120 DESCRIPTION:\n\
8121 \n\
8122  Sets font characteristics to be used at the start of the next string\n\
8123  using the FCI approach. See the PLplot documentation for more\n\
8124  information. \n\
8125 \n\
8126  Redacted form: General: plsfci(fci)\n\
8127 \t Perl/PDL: Not available? \n\
8128 \n\
8129 \n\
8130  This function is used in example 23. \n\
8131 \n\
8132 \n\
8133 \n\
8134 SYNOPSIS:\n\
8135 \n\
8136 plsfci(fci)\n\
8137 \n\
8138 ARGUMENTS:\n\
8139 \n\
8140  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
8141  of FCI. \n\
8142 ";
8143 const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
8144 Select area fill pattern \n\
8145 \n\
8146 DESCRIPTION:\n\
8147 \n\
8148  Select one of eight predefined area fill patterns to use (also see\n\
8149  plpat). Setting the fill style to 0 gives a solid fill. \n\
8150 \n\
8151  Redacted form: plpsty(n)\n\
8152 \n\
8153  This function is used in examples 12,13,15,16,25. \n\
8154 \n\
8155 \n\
8156 \n\
8157 SYNOPSIS:\n\
8158 \n\
8159 plpsty(n)\n\
8160 \n\
8161 ARGUMENTS:\n\
8162 \n\
8163  n (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
8164  horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
8165  consists of lines at 45 degrees angle (upward), and so on. \n\
8166 ";
8167 const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
8168 Set symbol size \n\
8169 \n\
8170 DESCRIPTION:\n\
8171 \n\
8172  This sets up the size of all subsequent symbols drawn by plpoin and\n\
8173  plsym. The actual height of a symbol is the product of the default\n\
8174  symbol size and a scaling factor as for the character height. \n\
8175 \n\
8176  Redacted form: plssym(def, scale)\n\
8177 \n\
8178  This function is used in example 29. \n\
8179 \n\
8180 \n\
8181 \n\
8182 SYNOPSIS:\n\
8183 \n\
8184 plssym(def, scale)\n\
8185 \n\
8186 ARGUMENTS:\n\
8187 \n\
8188  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
8189  should be set to zero if the default height is to remain\n\
8190  unchanged. \n\
8191 \n\
8192  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
8193  actual symbol height. \n\
8194 ";
8195 const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
8196 Initialization \n\
8197 \n\
8198 DESCRIPTION:\n\
8199 \n\
8200  Alternative to plstar for initializing the plotting package. The\n\
8201  device name keyword for the desired output device must be supplied as\n\
8202  an argument. The device keywords are the same as those printed out by\n\
8203  plstar. If the requested device is not available, or if the input\n\
8204  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
8205  is used. This routine also divides the output device into nx by ny\n\
8206  subpages, each of which may be used independently.\tThe subroutine\n\
8207  pladv is used to advance from one subpage to the next. \n\
8208 \n\
8209  Redacted form: General: plstart(device, nx, ny)\n\
8210 \t Perl/PDL: plstart(nx, ny, device)\n\
8211 \n\
8212 \n\
8213  This function is not used in any examples. \n\
8214 \n\
8215 \n\
8216 \n\
8217 SYNOPSIS:\n\
8218 \n\
8219 plstart(device, nx, ny)\n\
8220 \n\
8221 ARGUMENTS:\n\
8222 \n\
8223  device (const char *, input) : Device name (keyword) of the\n\
8224  required output device. If NULL or if the first character is a\n\
8225  ``?\'\', the normal (prompted) start up is used. \n\
8226 \n\
8227  nx (PLINT, input) : Number of subpages to divide output page in the\n\
8228  horizontal direction. \n\
8229 \n\
8230  ny (PLINT, input) : Number of subpages to divide output page in the\n\
8231  vertical direction. \n\
8232 ";
8233 
8234 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
8235  PLINT arg1 ;
8236  PLINT *arg2 = (PLINT *) 0 ;
8237  char **arg3 = (char **) 0 ;
8238  Matrix temp1 ;
8239  octave_value_list _out;
8240  octave_value_list *_outp=&_out;
8241  octave_value _outv;
8242 
8243  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
8244  SWIG_fail;
8245  }
8246  {
8247  if ( _n_dims( args(0) ) > 1 )
8248  {
8249  error( "argument must be a scalar or vector" ); SWIG_fail;
8250  }
8251  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
8252  arg2 = new PLINT[Alen];
8253  temp1 = args(0).matrix_value();
8254  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
8255  }
8256  {
8257  charMatrix temp_matrix;
8258  Cell temp_cell;
8259  char *tmp_cstring;
8260  std::string str;
8261  size_t max_length = 0, non_blank_length;
8262  int i, ifcell;
8263  if ( _n_dims( args(1) ) > 2 )
8264  {
8265  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
8266  }
8267  if ( !args(1).is_empty() )
8268  {
8269  if ( _dim( args(1), 0 ) != Alen )
8270  {
8271  error( "first dimension must be same length as previous vector" ); SWIG_fail;
8272  }
8273  arg3 = new char*[Alen];
8274  ifcell = args(1).is_cell();
8275  if ( ifcell )
8276  {
8277  temp_cell = args(1).cell_value();
8278  }
8279  else
8280  {
8281  temp_matrix = args(1).char_matrix_value();
8282  // Allow one extra space for null termination.
8283  max_length = _dim( args(1), 1 ) + 1;
8284  }
8285 
8286  for ( i = 0; i < Alen; i++ )
8287  {
8288  // Must copy string to "permanent" location because the string
8289  // location corresponding to tmp_cstring gets
8290  // overwritten for each iteration of loop.
8291  if ( ifcell )
8292  {
8293  if ( temp_cell.elem( i ).is_string() )
8294  {
8295  str = temp_cell.elem( i ).string_value();
8296  // leave room for null termination.
8297  max_length = str.size() + 1;
8298  tmp_cstring = (char *) str.c_str();
8299  }
8300  else
8301  {
8302  // Use null string if user attempts to pass a cell array
8303  // with a non-string element (likely an empty element
8304  // since that should be allowed by the PLplot interface
8305  // if that element is going to be unused).
8306  // leave room for null termination.
8307  max_length = 1;
8308  tmp_cstring = (char *) "";
8309  }
8310  }
8311  else
8312  {
8313  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
8314  }
8315  arg3[i] = new char[max_length];
8316  strncpy( arg3[i], tmp_cstring, max_length - 1 );
8317  arg3[i][max_length - 1] = '\0';
8318  // All the trailing blank crapola should not be needed for
8319  // string cell arrays.
8320  if ( !ifcell )
8321  {
8322  // remove trailing-blank padding that is used by the
8323  // charMatrix class to insure all strings in a given
8324  // charMatrix instance have the same length.
8325  // This transformation also removes legitimate trailing
8326  // blanks but there is nothing we can do about that
8327  // for the charMatrix class.
8328 
8329  // Look for trailing nulls first (just in case, although that
8330  // shouldn't happen if charMatrix implemented as documented)
8331  // before looking for trailing blanks.
8332  non_blank_length = max_length - 2;
8333  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
8334  {
8335  non_blank_length--;
8336  }
8337  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
8338  {
8339  non_blank_length--;
8340  }
8341  arg3[i][non_blank_length + 1] = '\0';
8342  }
8343  }
8344  }
8345  else
8346  {
8347  arg3 = NULL;
8348  }
8349  }
8350  testppchar(arg1,(int const *)arg2,(char const **)arg3);
8351  _outv = octave_value();
8352  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8353  {
8354  delete [] arg2;
8355  }
8356  {
8357  int i;
8358  if ( arg3 != NULL )
8359  {
8360  for ( i = 0; i < Alen; i++ )
8361  {
8362  delete[] arg3[i];
8363  }
8364  delete[] arg3;
8365  }
8366  }
8367 fail:
8368  return _out;
8369 }
8370 
8371 
8373  int *arg1 = (int *) 0 ;
8374  int *arg2 = (int *) 0 ;
8375  int *arg3 = (int *) 0 ;
8376  char *arg4 = (char *) 0 ;
8377  int *arg5 = (int *) 0 ;
8378  int *arg6 = (int *) 0 ;
8379  PLFLT *arg7 = (PLFLT *) 0 ;
8380  PLFLT *arg8 = (PLFLT *) 0 ;
8381  PLFLT *arg9 = (PLFLT *) 0 ;
8382  PLFLT *arg10 = (PLFLT *) 0 ;
8383  int *arg11 = (int *) 0 ;
8384  int temp1 ;
8385  int res1 = SWIG_TMPOBJ ;
8386  int temp2 ;
8387  int res2 = SWIG_TMPOBJ ;
8388  int temp3 ;
8389  int res3 = SWIG_TMPOBJ ;
8390  octave_value_list retval4 ;
8391  int temp5 ;
8392  int res5 = SWIG_TMPOBJ ;
8393  int temp6 ;
8394  int res6 = SWIG_TMPOBJ ;
8395  PLFLT temp7 ;
8396  int res7 = SWIG_TMPOBJ ;
8397  PLFLT temp8 ;
8398  int res8 = SWIG_TMPOBJ ;
8399  PLFLT temp9 ;
8400  int res9 = SWIG_TMPOBJ ;
8401  PLFLT temp10 ;
8402  int res10 = SWIG_TMPOBJ ;
8403  int temp11 ;
8404  int res11 = SWIG_TMPOBJ ;
8405  octave_value_list _out;
8406  octave_value_list *_outp=&_out;
8407  octave_value _outv;
8408  int result;
8409 
8410  arg1 = &temp1;
8411  arg2 = &temp2;
8412  arg3 = &temp3;
8413  {
8414  // Check if version >= 3.4.0
8415 # if OCTAVE_API_VERSION_NUMBER < 45
8416  retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
8417 # else
8418  retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
8419 # endif
8420  arg4 = (char *) retval4( 0 ).char_matrix_value().data();
8421  }
8422  arg5 = &temp5;
8423  arg6 = &temp6;
8424  arg7 = &temp7;
8425  arg8 = &temp8;
8426  arg9 = &temp9;
8427  arg10 = &temp10;
8428  arg11 = &temp11;
8429  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
8430  SWIG_fail;
8431  }
8432  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
8433  _outv = SWIG_From_int((int)(result));
8434  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8435  if (SWIG_IsTmpObj(res1)) {
8436  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8437  } else {
8438  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8439  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8440  }
8441  if (SWIG_IsTmpObj(res2)) {
8442  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
8443  } else {
8444  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8445  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8446  }
8447  if (SWIG_IsTmpObj(res3)) {
8448  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
8449  } else {
8450  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8451  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8452  }
8453  {
8454  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
8455  }
8456  if (SWIG_IsTmpObj(res5)) {
8457  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
8458  } else {
8459  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8460  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
8461  }
8462  if (SWIG_IsTmpObj(res6)) {
8463  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
8464  } else {
8465  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8466  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
8467  }
8468  if (SWIG_IsTmpObj(res7)) {
8469  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
8470  } else {
8471  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8472  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
8473  }
8474  if (SWIG_IsTmpObj(res8)) {
8475  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
8476  } else {
8477  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8478  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
8479  }
8480  if (SWIG_IsTmpObj(res9)) {
8481  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
8482  } else {
8483  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8484  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
8485  }
8486  if (SWIG_IsTmpObj(res10)) {
8487  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
8488  } else {
8489  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8490  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
8491  }
8492  if (SWIG_IsTmpObj(res11)) {
8493  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
8494  } else {
8495  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8496  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
8497  }
8498 fail:
8499  return _out;
8500 }
8501 
8502 
8503 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
8504  PLFLT *arg1 = (PLFLT *) 0 ;
8505  PLFLT *arg2 = (PLFLT *) 0 ;
8506  PLFLT arg3 ;
8507  PLFLT arg4 ;
8508  PLFLT temp1 ;
8509  int res1 = SWIG_TMPOBJ ;
8510  PLFLT temp2 ;
8511  int res2 = SWIG_TMPOBJ ;
8512  double val3 ;
8513  int ecode3 = 0 ;
8514  double val4 ;
8515  int ecode4 = 0 ;
8516  octave_value_list _out;
8517  octave_value_list *_outp=&_out;
8518  octave_value _outv;
8519  int result;
8520 
8521  arg1 = &temp1;
8522  arg2 = &temp2;
8523  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
8524  SWIG_fail;
8525  }
8526  ecode3 = SWIG_AsVal_double(args(0), &val3);
8527  if (!SWIG_IsOK(ecode3)) {
8528  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
8529  }
8530  arg3 = (PLFLT)(val3);
8531  ecode4 = SWIG_AsVal_double(args(1), &val4);
8532  if (!SWIG_IsOK(ecode4)) {
8533  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
8534  }
8535  arg4 = (PLFLT)(val4);
8536  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
8537  _outv = SWIG_From_int((int)(result));
8538  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8539  if (SWIG_IsTmpObj(res1)) {
8540  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
8541  } else {
8542  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8543  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8544  }
8545  if (SWIG_IsTmpObj(res2)) {
8546  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
8547  } else {
8548  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8549  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8550  }
8551 fail:
8552  return _out;
8553 }
8554 
8555 
8556 SWIG_DEFUN( plstripc, _wrap_plstripc, std::string() ) {
8557  PLINT *arg1 = (PLINT *) 0 ;
8558  char *arg2 = (char *) 0 ;
8559  char *arg3 = (char *) 0 ;
8560  PLFLT arg4 ;
8561  PLFLT arg5 ;
8562  PLFLT arg6 ;
8563  PLFLT arg7 ;
8564  PLFLT arg8 ;
8565  PLFLT arg9 ;
8566  PLFLT arg10 ;
8567  PLBOOL arg11 ;
8568  PLBOOL arg12 ;
8569  PLINT arg13 ;
8570  PLINT arg14 ;
8571  PLINT *arg15 = (PLINT *) 0 ;
8572  PLINT *arg16 = (PLINT *) 0 ;
8573  char *arg17 = (char *) 0 ;
8574  char *arg18 = (char *) 0 ;
8575  char *arg19 = (char *) 0 ;
8576  char *arg20 = (char *) 0 ;
8577  char *arg21 = (char *) 0 ;
8578  char *arg22 = (char *) 0 ;
8579  char *arg23 = (char *) 0 ;
8580  PLINT temp1 ;
8581  int res1 = SWIG_TMPOBJ ;
8582  int res2 ;
8583  char *buf2 = 0 ;
8584  int alloc2 = 0 ;
8585  int res3 ;
8586  char *buf3 = 0 ;
8587  int alloc3 = 0 ;
8588  double val4 ;
8589  int ecode4 = 0 ;
8590  double val5 ;
8591  int ecode5 = 0 ;
8592  double val6 ;
8593  int ecode6 = 0 ;
8594  double val7 ;
8595  int ecode7 = 0 ;
8596  double val8 ;
8597  int ecode8 = 0 ;
8598  double val9 ;
8599  int ecode9 = 0 ;
8600  double val10 ;
8601  int ecode10 = 0 ;
8602  int val11 ;
8603  int ecode11 = 0 ;
8604  int val12 ;
8605  int ecode12 = 0 ;
8606  int val13 ;
8607  int ecode13 = 0 ;
8608  int val14 ;
8609  int ecode14 = 0 ;
8610  Matrix temp15 ;
8611  Matrix temp16 ;
8612  int res17 ;
8613  char *buf17 = 0 ;
8614  int alloc17 = 0 ;
8615  int res18 ;
8616  char *buf18 = 0 ;
8617  int alloc18 = 0 ;
8618  int res19 ;
8619  char *buf19 = 0 ;
8620  int alloc19 = 0 ;
8621  int res20 ;
8622  char *buf20 = 0 ;
8623  int alloc20 = 0 ;
8624  int res21 ;
8625  char *buf21 = 0 ;
8626  int alloc21 = 0 ;
8627  int res22 ;
8628  char *buf22 = 0 ;
8629  int alloc22 = 0 ;
8630  int res23 ;
8631  char *buf23 = 0 ;
8632  int alloc23 = 0 ;
8633  octave_value_list _out;
8634  octave_value_list *_outp=&_out;
8635  octave_value _outv;
8636 
8637  arg1 = &temp1;
8638  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
8639  SWIG_fail;
8640  }
8641  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
8642  if (!SWIG_IsOK(res2)) {
8643  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
8644  }
8645  arg2 = (char *)(buf2);
8646  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
8647  if (!SWIG_IsOK(res3)) {
8648  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
8649  }
8650  arg3 = (char *)(buf3);
8651  ecode4 = SWIG_AsVal_double(args(2), &val4);
8652  if (!SWIG_IsOK(ecode4)) {
8653  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
8654  }
8655  arg4 = (PLFLT)(val4);
8656  ecode5 = SWIG_AsVal_double(args(3), &val5);
8657  if (!SWIG_IsOK(ecode5)) {
8658  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
8659  }
8660  arg5 = (PLFLT)(val5);
8661  ecode6 = SWIG_AsVal_double(args(4), &val6);
8662  if (!SWIG_IsOK(ecode6)) {
8663  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
8664  }
8665  arg6 = (PLFLT)(val6);
8666  ecode7 = SWIG_AsVal_double(args(5), &val7);
8667  if (!SWIG_IsOK(ecode7)) {
8668  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
8669  }
8670  arg7 = (PLFLT)(val7);
8671  ecode8 = SWIG_AsVal_double(args(6), &val8);
8672  if (!SWIG_IsOK(ecode8)) {
8673  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
8674  }
8675  arg8 = (PLFLT)(val8);
8676  ecode9 = SWIG_AsVal_double(args(7), &val9);
8677  if (!SWIG_IsOK(ecode9)) {
8678  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
8679  }
8680  arg9 = (PLFLT)(val9);
8681  ecode10 = SWIG_AsVal_double(args(8), &val10);
8682  if (!SWIG_IsOK(ecode10)) {
8683  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
8684  }
8685  arg10 = (PLFLT)(val10);
8686  ecode11 = SWIG_AsVal_int(args(9), &val11);
8687  if (!SWIG_IsOK(ecode11)) {
8688  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
8689  }
8690  arg11 = (PLBOOL)(val11);
8691  ecode12 = SWIG_AsVal_int(args(10), &val12);
8692  if (!SWIG_IsOK(ecode12)) {
8693  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
8694  }
8695  arg12 = (PLBOOL)(val12);
8696  ecode13 = SWIG_AsVal_int(args(11), &val13);
8697  if (!SWIG_IsOK(ecode13)) {
8698  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
8699  }
8700  arg13 = (PLINT)(val13);
8701  ecode14 = SWIG_AsVal_int(args(12), &val14);
8702  if (!SWIG_IsOK(ecode14)) {
8703  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
8704  }
8705  arg14 = (PLINT)(val14);
8706  {
8707  if ( _n_dims( args(13) ) > 1 )
8708  {
8709  error( "argument must be a scalar or vector" ); SWIG_fail;
8710  }
8711  Alen = (PLINT) ( _dim( args(13), 0 ) );
8712  temp15 = args(13).matrix_value();
8713  arg15 = new PLINT[Alen];
8714  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
8715  }
8716  {
8717  if ( _n_dims( args(14) ) > 1 )
8718  {
8719  error( "argument must be a scalar or vector" ); SWIG_fail;
8720  }
8721  if ( _dim( args(14), 0 ) != Alen )
8722  {
8723  error( "argument vectors must be same length" ); SWIG_fail;
8724  }
8725  temp16 = args(14).matrix_value();
8726  arg16 = new PLINT[Alen];
8727  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
8728  }
8729  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
8730  if (!SWIG_IsOK(res17)) {
8731  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
8732  }
8733  arg17 = (char *)(buf17);
8734  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
8735  if (!SWIG_IsOK(res18)) {
8736  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
8737  }
8738  arg18 = (char *)(buf18);
8739  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
8740  if (!SWIG_IsOK(res19)) {
8741  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
8742  }
8743  arg19 = (char *)(buf19);
8744  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
8745  if (!SWIG_IsOK(res20)) {
8746  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
8747  }
8748  arg20 = (char *)(buf20);
8749  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
8750  if (!SWIG_IsOK(res21)) {
8751  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
8752  }
8753  arg21 = (char *)(buf21);
8754  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
8755  if (!SWIG_IsOK(res22)) {
8756  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
8757  }
8758  arg22 = (char *)(buf22);
8759  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
8760  if (!SWIG_IsOK(res23)) {
8761  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
8762  }
8763  arg23 = (char *)(buf23);
8764  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);
8765  _outv = octave_value();
8766  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8767  if (SWIG_IsTmpObj(res1)) {
8768  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8769  } else {
8770  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8771  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8772  }
8773  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8774  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
8775  {
8776  delete [] arg15;
8777  }
8778  {
8779  delete [] arg16;
8780  }
8781  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
8782  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
8783  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
8784  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
8785  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
8786  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
8787  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
8788 fail:
8789  return _out;
8790 }
8791 
8792 
8793 SWIG_DEFUN( plcont, _wrap_plcont, std::string() ) {
8794  PLFLT *arg1 = (PLFLT *) 0 ;
8795  PLINT arg2 ;
8796  PLINT arg3 ;
8797  PLINT arg4 ;
8798  PLINT arg5 ;
8799  PLINT arg6 ;
8800  PLINT arg7 ;
8801  PLFLT *arg8 = (PLFLT *) 0 ;
8802  PLINT arg9 ;
8803  PLFLT *arg10 = (PLFLT *) 0 ;
8804  Matrix temp1 ;
8805  int val4 ;
8806  int ecode4 = 0 ;
8807  int val5 ;
8808  int ecode5 = 0 ;
8809  int val6 ;
8810  int ecode6 = 0 ;
8811  int val7 ;
8812  int ecode7 = 0 ;
8813  Matrix temp8 ;
8814  Matrix temp10 ;
8815  octave_value_list _out;
8816  octave_value_list *_outp=&_out;
8817  octave_value _outv;
8818 
8819  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
8820  SWIG_fail;
8821  }
8822  {
8823  if ( _n_dims( args(0) ) > 2 )
8824  {
8825  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8826  }
8827  temp1 = args(0).matrix_value();
8828  arg1 = &temp1( 0, 0 );
8829  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8830  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8831  }
8832  ecode4 = SWIG_AsVal_int(args(1), &val4);
8833  if (!SWIG_IsOK(ecode4)) {
8834  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
8835  }
8836  arg4 = (PLINT)(val4);
8837  ecode5 = SWIG_AsVal_int(args(2), &val5);
8838  if (!SWIG_IsOK(ecode5)) {
8839  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
8840  }
8841  arg5 = (PLINT)(val5);
8842  ecode6 = SWIG_AsVal_int(args(3), &val6);
8843  if (!SWIG_IsOK(ecode6)) {
8844  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
8845  }
8846  arg6 = (PLINT)(val6);
8847  ecode7 = SWIG_AsVal_int(args(4), &val7);
8848  if (!SWIG_IsOK(ecode7)) {
8849  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
8850  }
8851  arg7 = (PLINT)(val7);
8852  {
8853  if ( _n_dims( args(5) ) > 1 )
8854  {
8855  error( "argument must be a scalar or vector" ); SWIG_fail;
8856  }
8857  temp8 = args(5).matrix_value();
8858  arg8 = &temp8( 0, 0 );
8859  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8860  }
8861  {
8862  if ( _n_dims( args(6) ) > 1 )
8863  {
8864  error( "argument must be a scalar or vector" ); SWIG_fail;
8865  }
8866  if ( _dim( args(6), 0 ) != 6 )
8867  {
8868  error( "argument vectors must have length of 6" ); SWIG_fail;
8869  }
8870  temp10 = args(6).matrix_value();
8871  arg10 = &temp10( 0, 0 );
8872  }
8873  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
8874  _outv = octave_value();
8875  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8876  {
8877 
8878  }
8879  {
8880 
8881  }
8882  {
8883 
8884  }
8885 fail:
8886  return _out;
8887 }
8888 
8889 
8890 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
8891  PLFLT *arg1 = (PLFLT *) 0 ;
8892  PLINT arg2 ;
8893  PLINT arg3 ;
8894  PLINT arg4 ;
8895  PLINT arg5 ;
8896  PLINT arg6 ;
8897  PLINT arg7 ;
8898  PLFLT *arg8 = (PLFLT *) 0 ;
8899  PLINT arg9 ;
8900  Matrix temp1 ;
8901  int val4 ;
8902  int ecode4 = 0 ;
8903  int val5 ;
8904  int ecode5 = 0 ;
8905  int val6 ;
8906  int ecode6 = 0 ;
8907  int val7 ;
8908  int ecode7 = 0 ;
8909  Matrix temp8 ;
8910  octave_value_list _out;
8911  octave_value_list *_outp=&_out;
8912  octave_value _outv;
8913 
8914  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
8915  SWIG_fail;
8916  }
8917  {
8918  if ( _n_dims( args(0) ) > 2 )
8919  {
8920  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8921  }
8922  temp1 = args(0).matrix_value();
8923  arg1 = &temp1( 0, 0 );
8924  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8925  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8926  }
8927  ecode4 = SWIG_AsVal_int(args(1), &val4);
8928  if (!SWIG_IsOK(ecode4)) {
8929  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
8930  }
8931  arg4 = (PLINT)(val4);
8932  ecode5 = SWIG_AsVal_int(args(2), &val5);
8933  if (!SWIG_IsOK(ecode5)) {
8934  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
8935  }
8936  arg5 = (PLINT)(val5);
8937  ecode6 = SWIG_AsVal_int(args(3), &val6);
8938  if (!SWIG_IsOK(ecode6)) {
8939  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
8940  }
8941  arg6 = (PLINT)(val6);
8942  ecode7 = SWIG_AsVal_int(args(4), &val7);
8943  if (!SWIG_IsOK(ecode7)) {
8944  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
8945  }
8946  arg7 = (PLINT)(val7);
8947  {
8948  if ( _n_dims( args(5) ) > 1 )
8949  {
8950  error( "argument must be a scalar or vector" ); SWIG_fail;
8951  }
8952  temp8 = args(5).matrix_value();
8953  arg8 = &temp8( 0, 0 );
8954  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8955  }
8956  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
8957  _outv = octave_value();
8958  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8959  {
8960 
8961  }
8962  {
8963 
8964  }
8965 fail:
8966  return _out;
8967 }
8968 
8969 
8970 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
8971  PLFLT *arg1 = (PLFLT *) 0 ;
8972  PLINT arg2 ;
8973  PLINT arg3 ;
8974  PLINT arg4 ;
8975  PLINT arg5 ;
8976  PLINT arg6 ;
8977  PLINT arg7 ;
8978  PLFLT *arg8 = (PLFLT *) 0 ;
8979  PLINT arg9 ;
8980  PLFLT *arg10 = (PLFLT *) 0 ;
8981  PLFLT *arg11 = (PLFLT *) 0 ;
8982  Matrix temp1 ;
8983  int val4 ;
8984  int ecode4 = 0 ;
8985  int val5 ;
8986  int ecode5 = 0 ;
8987  int val6 ;
8988  int ecode6 = 0 ;
8989  int val7 ;
8990  int ecode7 = 0 ;
8991  Matrix temp8 ;
8992  Matrix temp10 ;
8993  Matrix temp11 ;
8994  octave_value_list _out;
8995  octave_value_list *_outp=&_out;
8996  octave_value _outv;
8997 
8998  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
8999  SWIG_fail;
9000  }
9001  {
9002  if ( _n_dims( args(0) ) > 2 )
9003  {
9004  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9005  }
9006  temp1 = args(0).matrix_value();
9007  arg1 = &temp1( 0, 0 );
9008  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9009  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9010  }
9011  ecode4 = SWIG_AsVal_int(args(1), &val4);
9012  if (!SWIG_IsOK(ecode4)) {
9013  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
9014  }
9015  arg4 = (PLINT)(val4);
9016  ecode5 = SWIG_AsVal_int(args(2), &val5);
9017  if (!SWIG_IsOK(ecode5)) {
9018  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
9019  }
9020  arg5 = (PLINT)(val5);
9021  ecode6 = SWIG_AsVal_int(args(3), &val6);
9022  if (!SWIG_IsOK(ecode6)) {
9023  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
9024  }
9025  arg6 = (PLINT)(val6);
9026  ecode7 = SWIG_AsVal_int(args(4), &val7);
9027  if (!SWIG_IsOK(ecode7)) {
9028  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
9029  }
9030  arg7 = (PLINT)(val7);
9031  {
9032  if ( _n_dims( args(5) ) > 1 )
9033  {
9034  error( "argument must be a scalar or vector" ); SWIG_fail;
9035  }
9036  temp8 = args(5).matrix_value();
9037  arg8 = &temp8( 0, 0 );
9038  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9039  }
9040  {
9041  if ( _n_dims( args(6) ) > 1 )
9042  {
9043  error( "argument must be a scalar or vector" ); SWIG_fail;
9044  }
9045  if ( _dim( args(6), 0 ) != Xlen )
9046  {
9047  error( "argument vectors must be same length" ); SWIG_fail;
9048  }
9049  temp10 = args(6).matrix_value();
9050  arg10 = &temp10( 0, 0 );
9051  }
9052  {
9053  if ( _n_dims( args(7) ) > 1 )
9054  {
9055  error( "argument must be a scalar or vector" ); SWIG_fail;
9056  }
9057  if ( _dim( args(7), 0 ) != Ylen )
9058  {
9059  error( "argument vectors must be same length" ); SWIG_fail;
9060  }
9061  temp11 = args(7).matrix_value();
9062  arg11 = &temp11( 0, 0 );
9063  }
9064  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9065  _outv = octave_value();
9066  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9067  {
9068 
9069  }
9070  {
9071 
9072  }
9073  {
9074 
9075  }
9076  {
9077 
9078  }
9079 fail:
9080  return _out;
9081 }
9082 
9083 
9084 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
9085  PLFLT *arg1 = (PLFLT *) 0 ;
9086  PLINT arg2 ;
9087  PLINT arg3 ;
9088  PLINT arg4 ;
9089  PLINT arg5 ;
9090  PLINT arg6 ;
9091  PLINT arg7 ;
9092  PLFLT *arg8 = (PLFLT *) 0 ;
9093  PLINT arg9 ;
9094  PLFLT *arg10 = (PLFLT *) 0 ;
9095  PLFLT *arg11 = (PLFLT *) 0 ;
9096  Matrix temp1 ;
9097  int val4 ;
9098  int ecode4 = 0 ;
9099  int val5 ;
9100  int ecode5 = 0 ;
9101  int val6 ;
9102  int ecode6 = 0 ;
9103  int val7 ;
9104  int ecode7 = 0 ;
9105  Matrix temp8 ;
9106  Matrix temp10 ;
9107  Matrix temp11 ;
9108  octave_value_list _out;
9109  octave_value_list *_outp=&_out;
9110  octave_value _outv;
9111 
9112  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
9113  SWIG_fail;
9114  }
9115  {
9116  if ( _n_dims( args(0) ) > 2 )
9117  {
9118  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9119  }
9120  temp1 = args(0).matrix_value();
9121  arg1 = &temp1( 0, 0 );
9122  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9123  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9124  }
9125  ecode4 = SWIG_AsVal_int(args(1), &val4);
9126  if (!SWIG_IsOK(ecode4)) {
9127  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
9128  }
9129  arg4 = (PLINT)(val4);
9130  ecode5 = SWIG_AsVal_int(args(2), &val5);
9131  if (!SWIG_IsOK(ecode5)) {
9132  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
9133  }
9134  arg5 = (PLINT)(val5);
9135  ecode6 = SWIG_AsVal_int(args(3), &val6);
9136  if (!SWIG_IsOK(ecode6)) {
9137  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
9138  }
9139  arg6 = (PLINT)(val6);
9140  ecode7 = SWIG_AsVal_int(args(4), &val7);
9141  if (!SWIG_IsOK(ecode7)) {
9142  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
9143  }
9144  arg7 = (PLINT)(val7);
9145  {
9146  if ( _n_dims( args(5) ) > 1 )
9147  {
9148  error( "argument must be a scalar or vector" ); SWIG_fail;
9149  }
9150  temp8 = args(5).matrix_value();
9151  arg8 = &temp8( 0, 0 );
9152  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9153  }
9154  {
9155  if ( _n_dims( args(6) ) > 2 )
9156  {
9157  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9158  }
9159  if ( _dim( args(6), 0 ) != Xlen )
9160  {
9161  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9162  }
9163  if ( _dim( args(6), 1 ) != Ylen )
9164  {
9165  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9166  }
9167  temp10 = args(6).matrix_value();
9168  arg10 = &temp10( 0, 0 );
9169  }
9170  {
9171  if ( _n_dims( args(7) ) > 2 )
9172  {
9173  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9174  }
9175  if ( _dim( args(7), 0 ) != Xlen )
9176  {
9177  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9178  }
9179  if ( _dim( args(7), 1 ) != Ylen )
9180  {
9181  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9182  }
9183  temp11 = args(7).matrix_value();
9184  arg11 = &temp11( 0, 0 );
9185  }
9186  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9187  _outv = octave_value();
9188  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9189  {
9190 
9191  }
9192  {
9193 
9194  }
9195  {
9196 
9197  }
9198  {
9199 
9200  }
9201 fail:
9202  return _out;
9203 }
9204 
9205 
9206 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
9207  PLFLT *arg1 = (PLFLT *) 0 ;
9208  PLINT arg2 ;
9209  PLINT arg3 ;
9210  PLINT arg4 ;
9211  PLINT arg5 ;
9212  PLINT arg6 ;
9213  PLINT arg7 ;
9214  PLFLT *arg8 = (PLFLT *) 0 ;
9215  PLINT arg9 ;
9216  PLFLT *arg10 = (PLFLT *) 0 ;
9217  PLFLT *arg11 = (PLFLT *) 0 ;
9218  Matrix temp1 ;
9219  int val4 ;
9220  int ecode4 = 0 ;
9221  int val5 ;
9222  int ecode5 = 0 ;
9223  int val6 ;
9224  int ecode6 = 0 ;
9225  int val7 ;
9226  int ecode7 = 0 ;
9227  Matrix temp8 ;
9228  Matrix temp10 ;
9229  Matrix temp11 ;
9230  octave_value_list _out;
9231  octave_value_list *_outp=&_out;
9232  octave_value _outv;
9233 
9234  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
9235  SWIG_fail;
9236  }
9237  {
9238  if ( _n_dims( args(0) ) > 2 )
9239  {
9240  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9241  }
9242  temp1 = args(0).matrix_value();
9243  arg1 = &temp1( 0, 0 );
9244  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9245  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9246  }
9247  ecode4 = SWIG_AsVal_int(args(1), &val4);
9248  if (!SWIG_IsOK(ecode4)) {
9249  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
9250  }
9251  arg4 = (PLINT)(val4);
9252  ecode5 = SWIG_AsVal_int(args(2), &val5);
9253  if (!SWIG_IsOK(ecode5)) {
9254  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
9255  }
9256  arg5 = (PLINT)(val5);
9257  ecode6 = SWIG_AsVal_int(args(3), &val6);
9258  if (!SWIG_IsOK(ecode6)) {
9259  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
9260  }
9261  arg6 = (PLINT)(val6);
9262  ecode7 = SWIG_AsVal_int(args(4), &val7);
9263  if (!SWIG_IsOK(ecode7)) {
9264  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
9265  }
9266  arg7 = (PLINT)(val7);
9267  {
9268  if ( _n_dims( args(5) ) > 1 )
9269  {
9270  error( "argument must be a scalar or vector" ); SWIG_fail;
9271  }
9272  temp8 = args(5).matrix_value();
9273  arg8 = &temp8( 0, 0 );
9274  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9275  }
9276  {
9277  if ( _n_dims( args(6) ) > 2 )
9278  {
9279  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9280  }
9281  if ( _dim( args(6), 0 ) != Xlen )
9282  {
9283  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9284  }
9285  if ( _dim( args(6), 1 ) != Ylen )
9286  {
9287  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9288  }
9289  temp10 = args(6).matrix_value();
9290  arg10 = &temp10( 0, 0 );
9291  }
9292  {
9293  if ( _n_dims( args(7) ) > 2 )
9294  {
9295  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9296  }
9297  if ( _dim( args(7), 0 ) != Xlen )
9298  {
9299  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9300  }
9301  if ( _dim( args(7), 1 ) != Ylen )
9302  {
9303  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9304  }
9305  temp11 = args(7).matrix_value();
9306  arg11 = &temp11( 0, 0 );
9307  }
9308  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9309  _outv = octave_value();
9310  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9311  {
9312 
9313  }
9314  {
9315 
9316  }
9317  {
9318 
9319  }
9320  {
9321 
9322  }
9323 fail:
9324  return _out;
9325 }
9326 
9327 
9329  PLFLT *arg1 = (PLFLT *) 0 ;
9330  PLFLT *arg2 = (PLFLT *) 0 ;
9331  PLFLT *arg3 = (PLFLT *) 0 ;
9332  PLINT arg4 ;
9333  PLFLT *arg5 = (PLFLT *) 0 ;
9334  PLINT arg6 ;
9335  PLFLT *arg7 = (PLFLT *) 0 ;
9336  PLINT arg8 ;
9337  PLFLT *arg9 = (PLFLT *) 0 ;
9338  PLINT arg10 ;
9339  PLFLT arg11 ;
9340  Matrix temp1 ;
9341  Matrix temp2 ;
9342  Matrix temp3 ;
9343  Matrix temp5 ;
9344  Matrix temp7 ;
9345  octave_value_list retval7 ;
9346  int val10 ;
9347  int ecode10 = 0 ;
9348  double val11 ;
9349  int ecode11 = 0 ;
9350  octave_value_list _out;
9351  octave_value_list *_outp=&_out;
9352  octave_value _outv;
9353 
9354  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
9355  SWIG_fail;
9356  }
9357  {
9358  if ( _n_dims( args(0) ) > 1 )
9359  {
9360  error( "argument must be a scalar or vector" ); SWIG_fail;
9361  }
9362  Alen = (PLINT) ( _dim( args(0), 0 ) );
9363  temp1 = args(0).matrix_value();
9364  arg1 = &temp1( 0, 0 );
9365  }
9366  {
9367  if ( _n_dims( args(1) ) > 1 )
9368  {
9369  error( "argument must be a scalar or vector" ); SWIG_fail;
9370  }
9371  if ( _dim( args(1), 0 ) != Alen )
9372  {
9373  error( "argument vectors must be same length" ); SWIG_fail;
9374  }
9375  temp2 = args(1).matrix_value();
9376  arg2 = &temp2( 0, 0 );
9377  }
9378  {
9379  if ( _n_dims( args(2) ) > 1 )
9380  {
9381  error( "argument must be a scalar or vector" ); SWIG_fail;
9382  }
9383  if ( _dim( args(2), 0 ) != Alen )
9384  {
9385  error( "argument vectors must be same length" ); SWIG_fail;
9386  }
9387  temp3 = args(2).matrix_value();
9388  arg3 = &temp3( 0, 0 );
9389  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9390  }
9391  {
9392  if ( _n_dims( args(3) ) > 1 )
9393  {
9394  error( "argument must be a scalar or vector" ); SWIG_fail;
9395  }
9396  temp5 = args(3).matrix_value();
9397  arg5 = &temp5( 0, 0 );
9398  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
9399  }
9400  {
9401  if ( _n_dims( args(4) ) > 1 )
9402  {
9403  error( "argument must be a scalar or vector" ); SWIG_fail;
9404  }
9405  temp7 = args(4).matrix_value();
9406  arg7 = &temp7( 0, 0 );
9407  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
9408  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
9409  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
9410  }
9411  ecode10 = SWIG_AsVal_int(args(5), &val10);
9412  if (!SWIG_IsOK(ecode10)) {
9413  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
9414  }
9415  arg10 = (PLINT)(val10);
9416  ecode11 = SWIG_AsVal_double(args(6), &val11);
9417  if (!SWIG_IsOK(ecode11)) {
9418  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
9419  }
9420  arg11 = (PLFLT)(val11);
9421  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
9422  _outv = octave_value();
9423  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9424  {
9425  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
9426  }
9427  {
9428 
9429  }
9430  {
9431 
9432  }
9433  {
9434 
9435  }
9436  {
9437 
9438  }
9439  {
9440 
9441  }
9442 fail:
9443  return _out;
9444 }
9445 
9446 
9447 SWIG_DEFUN( plmesh, _wrap_plmesh, std::string() ) {
9448  PLFLT *arg1 = (PLFLT *) 0 ;
9449  PLFLT *arg2 = (PLFLT *) 0 ;
9450  PLFLT *arg3 = (PLFLT *) 0 ;
9451  PLINT arg4 ;
9452  PLINT arg5 ;
9453  PLINT arg6 ;
9454  Matrix temp1 ;
9455  Matrix temp2 ;
9456  Matrix temp3 ;
9457  int val6 ;
9458  int ecode6 = 0 ;
9459  octave_value_list _out;
9460  octave_value_list *_outp=&_out;
9461  octave_value _outv;
9462 
9463  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
9464  SWIG_fail;
9465  }
9466  {
9467  if ( _n_dims( args(0) ) > 1 )
9468  {
9469  error( "argument must be a scalar or vector" ); SWIG_fail;
9470  }
9471  temp1 = args(0).matrix_value();
9472  arg1 = &temp1( 0, 0 );
9473  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9474  }
9475  {
9476  if ( _n_dims( args(1) ) > 1 )
9477  {
9478  error( "argument must be a scalar or vector" ); SWIG_fail;
9479  }
9480  temp2 = args(1).matrix_value();
9481  arg2 = &temp2( 0, 0 );
9482  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9483  }
9484  {
9485  if ( _n_dims( args(2) ) > 2 )
9486  {
9487  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9488  }
9489  if ( _dim( args(2), 0 ) != Xlen )
9490  {
9491  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9492  }
9493  if ( _dim( args(2), 1 ) != Ylen )
9494  {
9495  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9496  }
9497  temp3 = args(2).matrix_value();
9498  arg3 = &temp3( 0, 0 );
9499  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9500  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9501  }
9502  ecode6 = SWIG_AsVal_int(args(3), &val6);
9503  if (!SWIG_IsOK(ecode6)) {
9504  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9505  }
9506  arg6 = (PLINT)(val6);
9507  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
9508  _outv = octave_value();
9509  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9510  {
9511 
9512  }
9513  {
9514 
9515  }
9516  {
9517 
9518  }
9519 fail:
9520  return _out;
9521 }
9522 
9523 
9524 SWIG_DEFUN( plmeshc, _wrap_plmeshc, std::string() ) {
9525  PLFLT *arg1 = (PLFLT *) 0 ;
9526  PLFLT *arg2 = (PLFLT *) 0 ;
9527  PLFLT *arg3 = (PLFLT *) 0 ;
9528  PLINT arg4 ;
9529  PLINT arg5 ;
9530  PLINT arg6 ;
9531  PLFLT *arg7 = (PLFLT *) 0 ;
9532  PLINT arg8 ;
9533  Matrix temp1 ;
9534  Matrix temp2 ;
9535  Matrix temp3 ;
9536  int val6 ;
9537  int ecode6 = 0 ;
9538  Matrix temp7 ;
9539  octave_value_list _out;
9540  octave_value_list *_outp=&_out;
9541  octave_value _outv;
9542 
9543  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
9544  SWIG_fail;
9545  }
9546  {
9547  if ( _n_dims( args(0) ) > 1 )
9548  {
9549  error( "argument must be a scalar or vector" ); SWIG_fail;
9550  }
9551  temp1 = args(0).matrix_value();
9552  arg1 = &temp1( 0, 0 );
9553  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9554  }
9555  {
9556  if ( _n_dims( args(1) ) > 1 )
9557  {
9558  error( "argument must be a scalar or vector" ); SWIG_fail;
9559  }
9560  temp2 = args(1).matrix_value();
9561  arg2 = &temp2( 0, 0 );
9562  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9563  }
9564  {
9565  if ( _n_dims( args(2) ) > 2 )
9566  {
9567  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9568  }
9569  if ( _dim( args(2), 0 ) != Xlen )
9570  {
9571  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9572  }
9573  if ( _dim( args(2), 1 ) != Ylen )
9574  {
9575  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9576  }
9577  temp3 = args(2).matrix_value();
9578  arg3 = &temp3( 0, 0 );
9579  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9580  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9581  }
9582  ecode6 = SWIG_AsVal_int(args(3), &val6);
9583  if (!SWIG_IsOK(ecode6)) {
9584  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9585  }
9586  arg6 = (PLINT)(val6);
9587  {
9588  if ( _n_dims( args(4) ) > 1 )
9589  {
9590  error( "argument must be a scalar or vector" ); SWIG_fail;
9591  }
9592  temp7 = args(4).matrix_value();
9593  arg7 = &temp7( 0, 0 );
9594  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9595  }
9596  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9597  _outv = octave_value();
9598  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9599  {
9600 
9601  }
9602  {
9603 
9604  }
9605  {
9606 
9607  }
9608  {
9609 
9610  }
9611 fail:
9612  return _out;
9613 }
9614 
9615 
9616 SWIG_DEFUN( plot3d, _wrap_plot3d, std::string() ) {
9617  PLFLT *arg1 = (PLFLT *) 0 ;
9618  PLFLT *arg2 = (PLFLT *) 0 ;
9619  PLFLT *arg3 = (PLFLT *) 0 ;
9620  PLINT arg4 ;
9621  PLINT arg5 ;
9622  PLINT arg6 ;
9623  PLBOOL arg7 ;
9624  Matrix temp1 ;
9625  Matrix temp2 ;
9626  Matrix temp3 ;
9627  int val6 ;
9628  int ecode6 = 0 ;
9629  int val7 ;
9630  int ecode7 = 0 ;
9631  octave_value_list _out;
9632  octave_value_list *_outp=&_out;
9633  octave_value _outv;
9634 
9635  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
9636  SWIG_fail;
9637  }
9638  {
9639  if ( _n_dims( args(0) ) > 1 )
9640  {
9641  error( "argument must be a scalar or vector" ); SWIG_fail;
9642  }
9643  temp1 = args(0).matrix_value();
9644  arg1 = &temp1( 0, 0 );
9645  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9646  }
9647  {
9648  if ( _n_dims( args(1) ) > 1 )
9649  {
9650  error( "argument must be a scalar or vector" ); SWIG_fail;
9651  }
9652  temp2 = args(1).matrix_value();
9653  arg2 = &temp2( 0, 0 );
9654  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9655  }
9656  {
9657  if ( _n_dims( args(2) ) > 2 )
9658  {
9659  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9660  }
9661  if ( _dim( args(2), 0 ) != Xlen )
9662  {
9663  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9664  }
9665  if ( _dim( args(2), 1 ) != Ylen )
9666  {
9667  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9668  }
9669  temp3 = args(2).matrix_value();
9670  arg3 = &temp3( 0, 0 );
9671  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9672  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9673  }
9674  ecode6 = SWIG_AsVal_int(args(3), &val6);
9675  if (!SWIG_IsOK(ecode6)) {
9676  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9677  }
9678  arg6 = (PLINT)(val6);
9679  ecode7 = SWIG_AsVal_int(args(4), &val7);
9680  if (!SWIG_IsOK(ecode7)) {
9681  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9682  }
9683  arg7 = (PLBOOL)(val7);
9684  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
9685  _outv = octave_value();
9686  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9687  {
9688 
9689  }
9690  {
9691 
9692  }
9693  {
9694 
9695  }
9696 fail:
9697  return _out;
9698 }
9699 
9700 
9701 SWIG_DEFUN( plot3dc, _wrap_plot3dc, std::string() ) {
9702  PLFLT *arg1 = (PLFLT *) 0 ;
9703  PLFLT *arg2 = (PLFLT *) 0 ;
9704  PLFLT *arg3 = (PLFLT *) 0 ;
9705  PLINT arg4 ;
9706  PLINT arg5 ;
9707  PLINT arg6 ;
9708  PLFLT *arg7 = (PLFLT *) 0 ;
9709  PLINT arg8 ;
9710  Matrix temp1 ;
9711  Matrix temp2 ;
9712  Matrix temp3 ;
9713  int val6 ;
9714  int ecode6 = 0 ;
9715  Matrix temp7 ;
9716  octave_value_list _out;
9717  octave_value_list *_outp=&_out;
9718  octave_value _outv;
9719 
9720  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
9721  SWIG_fail;
9722  }
9723  {
9724  if ( _n_dims( args(0) ) > 1 )
9725  {
9726  error( "argument must be a scalar or vector" ); SWIG_fail;
9727  }
9728  temp1 = args(0).matrix_value();
9729  arg1 = &temp1( 0, 0 );
9730  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9731  }
9732  {
9733  if ( _n_dims( args(1) ) > 1 )
9734  {
9735  error( "argument must be a scalar or vector" ); SWIG_fail;
9736  }
9737  temp2 = args(1).matrix_value();
9738  arg2 = &temp2( 0, 0 );
9739  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9740  }
9741  {
9742  if ( _n_dims( args(2) ) > 2 )
9743  {
9744  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9745  }
9746  if ( _dim( args(2), 0 ) != Xlen )
9747  {
9748  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9749  }
9750  if ( _dim( args(2), 1 ) != Ylen )
9751  {
9752  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9753  }
9754  temp3 = args(2).matrix_value();
9755  arg3 = &temp3( 0, 0 );
9756  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9757  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9758  }
9759  ecode6 = SWIG_AsVal_int(args(3), &val6);
9760  if (!SWIG_IsOK(ecode6)) {
9761  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9762  }
9763  arg6 = (PLINT)(val6);
9764  {
9765  if ( _n_dims( args(4) ) > 1 )
9766  {
9767  error( "argument must be a scalar or vector" ); SWIG_fail;
9768  }
9769  temp7 = args(4).matrix_value();
9770  arg7 = &temp7( 0, 0 );
9771  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9772  }
9773  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9774  _outv = octave_value();
9775  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9776  {
9777 
9778  }
9779  {
9780 
9781  }
9782  {
9783 
9784  }
9785  {
9786 
9787  }
9788 fail:
9789  return _out;
9790 }
9791 
9792 
9793 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, std::string() ) {
9794  PLFLT *arg1 = (PLFLT *) 0 ;
9795  PLFLT *arg2 = (PLFLT *) 0 ;
9796  PLFLT *arg3 = (PLFLT *) 0 ;
9797  PLINT arg4 ;
9798  PLINT arg5 ;
9799  PLINT arg6 ;
9800  PLFLT *arg7 = (PLFLT *) 0 ;
9801  PLINT arg8 ;
9802  Matrix temp1 ;
9803  Matrix temp2 ;
9804  Matrix temp3 ;
9805  int val6 ;
9806  int ecode6 = 0 ;
9807  Matrix temp7 ;
9808  octave_value_list _out;
9809  octave_value_list *_outp=&_out;
9810  octave_value _outv;
9811 
9812  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
9813  SWIG_fail;
9814  }
9815  {
9816  if ( _n_dims( args(0) ) > 1 )
9817  {
9818  error( "argument must be a scalar or vector" ); SWIG_fail;
9819  }
9820  temp1 = args(0).matrix_value();
9821  arg1 = &temp1( 0, 0 );
9822  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9823  }
9824  {
9825  if ( _n_dims( args(1) ) > 1 )
9826  {
9827  error( "argument must be a scalar or vector" ); SWIG_fail;
9828  }
9829  temp2 = args(1).matrix_value();
9830  arg2 = &temp2( 0, 0 );
9831  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9832  }
9833  {
9834  if ( _n_dims( args(2) ) > 2 )
9835  {
9836  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9837  }
9838  if ( _dim( args(2), 0 ) != Xlen )
9839  {
9840  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9841  }
9842  if ( _dim( args(2), 1 ) != Ylen )
9843  {
9844  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9845  }
9846  temp3 = args(2).matrix_value();
9847  arg3 = &temp3( 0, 0 );
9848  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9849  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9850  }
9851  ecode6 = SWIG_AsVal_int(args(3), &val6);
9852  if (!SWIG_IsOK(ecode6)) {
9853  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9854  }
9855  arg6 = (PLINT)(val6);
9856  {
9857  if ( _n_dims( args(4) ) > 1 )
9858  {
9859  error( "argument must be a scalar or vector" ); SWIG_fail;
9860  }
9861  temp7 = args(4).matrix_value();
9862  arg7 = &temp7( 0, 0 );
9863  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9864  }
9865  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9866  _outv = octave_value();
9867  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9868  {
9869 
9870  }
9871  {
9872 
9873  }
9874  {
9875 
9876  }
9877  {
9878 
9879  }
9880 fail:
9881  return _out;
9882 }
9883 
9884 
9885 SWIG_DEFUN( plshade, _wrap_plshade, std::string() ) {
9886  PLFLT *arg1 = (PLFLT *) 0 ;
9887  PLINT arg2 ;
9888  PLINT arg3 ;
9889  PLFLT *arg4 = (PLFLT *) 0 ;
9890  PLFLT arg5 ;
9891  PLFLT arg6 ;
9892  PLFLT arg7 ;
9893  PLFLT arg8 ;
9894  PLFLT arg9 ;
9895  PLFLT arg10 ;
9896  PLINT arg11 ;
9897  PLFLT arg12 ;
9898  PLINT arg13 ;
9899  PLINT arg14 ;
9900  PLINT arg15 ;
9901  PLINT arg16 ;
9902  PLINT arg17 ;
9903  PLBOOL arg18 ;
9904  PLFLT *arg19 = (PLFLT *) 0 ;
9905  Matrix temp1 ;
9906  Matrix temp4 ;
9907  double val5 ;
9908  int ecode5 = 0 ;
9909  double val6 ;
9910  int ecode6 = 0 ;
9911  double val7 ;
9912  int ecode7 = 0 ;
9913  double val8 ;
9914  int ecode8 = 0 ;
9915  double val9 ;
9916  int ecode9 = 0 ;
9917  double val10 ;
9918  int ecode10 = 0 ;
9919  int val11 ;
9920  int ecode11 = 0 ;
9921  double val12 ;
9922  int ecode12 = 0 ;
9923  int val13 ;
9924  int ecode13 = 0 ;
9925  int val14 ;
9926  int ecode14 = 0 ;
9927  int val15 ;
9928  int ecode15 = 0 ;
9929  int val16 ;
9930  int ecode16 = 0 ;
9931  int val17 ;
9932  int ecode17 = 0 ;
9933  int val18 ;
9934  int ecode18 = 0 ;
9935  Matrix temp19 ;
9936  octave_value_list _out;
9937  octave_value_list *_outp=&_out;
9938  octave_value _outv;
9939 
9940  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
9941  SWIG_fail;
9942  }
9943  {
9944  if ( _n_dims( args(0) ) > 2 )
9945  {
9946  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9947  }
9948  temp1 = args(0).matrix_value();
9949  arg1 = &temp1( 0, 0 );
9950  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9951  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9952  }
9953  {
9954  if ( _n_dims( args(1) ) > 1 )
9955  {
9956  error( "argument must be a scalar or vector" ); SWIG_fail;
9957  }
9958  Alen = (PLINT) ( _dim( args(1), 0 ) );
9959  temp4 = args(1).matrix_value();
9960  arg4 = &temp4( 0, 0 );
9961  }
9962  ecode5 = SWIG_AsVal_double(args(2), &val5);
9963  if (!SWIG_IsOK(ecode5)) {
9964  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
9965  }
9966  arg5 = (PLFLT)(val5);
9967  ecode6 = SWIG_AsVal_double(args(3), &val6);
9968  if (!SWIG_IsOK(ecode6)) {
9969  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
9970  }
9971  arg6 = (PLFLT)(val6);
9972  ecode7 = SWIG_AsVal_double(args(4), &val7);
9973  if (!SWIG_IsOK(ecode7)) {
9974  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
9975  }
9976  arg7 = (PLFLT)(val7);
9977  ecode8 = SWIG_AsVal_double(args(5), &val8);
9978  if (!SWIG_IsOK(ecode8)) {
9979  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
9980  }
9981  arg8 = (PLFLT)(val8);
9982  ecode9 = SWIG_AsVal_double(args(6), &val9);
9983  if (!SWIG_IsOK(ecode9)) {
9984  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
9985  }
9986  arg9 = (PLFLT)(val9);
9987  ecode10 = SWIG_AsVal_double(args(7), &val10);
9988  if (!SWIG_IsOK(ecode10)) {
9989  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
9990  }
9991  arg10 = (PLFLT)(val10);
9992  ecode11 = SWIG_AsVal_int(args(8), &val11);
9993  if (!SWIG_IsOK(ecode11)) {
9994  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
9995  }
9996  arg11 = (PLINT)(val11);
9997  ecode12 = SWIG_AsVal_double(args(9), &val12);
9998  if (!SWIG_IsOK(ecode12)) {
9999  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
10000  }
10001  arg12 = (PLFLT)(val12);
10002  ecode13 = SWIG_AsVal_int(args(10), &val13);
10003  if (!SWIG_IsOK(ecode13)) {
10004  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
10005  }
10006  arg13 = (PLINT)(val13);
10007  ecode14 = SWIG_AsVal_int(args(11), &val14);
10008  if (!SWIG_IsOK(ecode14)) {
10009  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
10010  }
10011  arg14 = (PLINT)(val14);
10012  ecode15 = SWIG_AsVal_int(args(12), &val15);
10013  if (!SWIG_IsOK(ecode15)) {
10014  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
10015  }
10016  arg15 = (PLINT)(val15);
10017  ecode16 = SWIG_AsVal_int(args(13), &val16);
10018  if (!SWIG_IsOK(ecode16)) {
10019  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
10020  }
10021  arg16 = (PLINT)(val16);
10022  ecode17 = SWIG_AsVal_int(args(14), &val17);
10023  if (!SWIG_IsOK(ecode17)) {
10024  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
10025  }
10026  arg17 = (PLINT)(val17);
10027  ecode18 = SWIG_AsVal_int(args(15), &val18);
10028  if (!SWIG_IsOK(ecode18)) {
10029  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
10030  }
10031  arg18 = (PLBOOL)(val18);
10032  {
10033  if ( _n_dims( args(16) ) > 1 )
10034  {
10035  error( "argument must be a scalar or vector" ); SWIG_fail;
10036  }
10037  if ( _dim( args(16), 0 ) != 6 )
10038  {
10039  error( "argument vectors must have length of 6" ); SWIG_fail;
10040  }
10041  temp19 = args(16).matrix_value();
10042  arg19 = &temp19( 0, 0 );
10043  }
10044  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);
10045  _outv = octave_value();
10046  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10047  {
10048 
10049  }
10050  {
10051 
10052  }
10053  {
10054 
10055  }
10056 fail:
10057  return _out;
10058 }
10059 
10060 
10061 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
10062  PLFLT *arg1 = (PLFLT *) 0 ;
10063  PLINT arg2 ;
10064  PLINT arg3 ;
10065  char *arg4 = (char *) 0 ;
10066  PLFLT arg5 ;
10067  PLFLT arg6 ;
10068  PLFLT arg7 ;
10069  PLFLT arg8 ;
10070  PLFLT arg9 ;
10071  PLFLT arg10 ;
10072  PLINT arg11 ;
10073  PLFLT arg12 ;
10074  PLINT arg13 ;
10075  PLINT arg14 ;
10076  PLINT arg15 ;
10077  PLINT arg16 ;
10078  PLINT arg17 ;
10079  PLBOOL arg18 ;
10080  PLFLT *arg19 = (PLFLT *) 0 ;
10081  PLFLT *arg20 = (PLFLT *) 0 ;
10082  Matrix temp1 ;
10083  int res4 ;
10084  char *buf4 = 0 ;
10085  int alloc4 = 0 ;
10086  double val5 ;
10087  int ecode5 = 0 ;
10088  double val6 ;
10089  int ecode6 = 0 ;
10090  double val7 ;
10091  int ecode7 = 0 ;
10092  double val8 ;
10093  int ecode8 = 0 ;
10094  double val9 ;
10095  int ecode9 = 0 ;
10096  double val10 ;
10097  int ecode10 = 0 ;
10098  int val11 ;
10099  int ecode11 = 0 ;
10100  double val12 ;
10101  int ecode12 = 0 ;
10102  int val13 ;
10103  int ecode13 = 0 ;
10104  int val14 ;
10105  int ecode14 = 0 ;
10106  int val15 ;
10107  int ecode15 = 0 ;
10108  int val16 ;
10109  int ecode16 = 0 ;
10110  int val17 ;
10111  int ecode17 = 0 ;
10112  int val18 ;
10113  int ecode18 = 0 ;
10114  Matrix temp19 ;
10115  Matrix temp20 ;
10116  octave_value_list _out;
10117  octave_value_list *_outp=&_out;
10118  octave_value _outv;
10119 
10120  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
10121  SWIG_fail;
10122  }
10123  {
10124  if ( _n_dims( args(0) ) > 2 )
10125  {
10126  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10127  }
10128  temp1 = args(0).matrix_value();
10129  arg1 = &temp1( 0, 0 );
10130  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10131  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10132  }
10133  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10134  if (!SWIG_IsOK(res4)) {
10135  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
10136  }
10137  arg4 = (char *)(buf4);
10138  ecode5 = SWIG_AsVal_double(args(2), &val5);
10139  if (!SWIG_IsOK(ecode5)) {
10140  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
10141  }
10142  arg5 = (PLFLT)(val5);
10143  ecode6 = SWIG_AsVal_double(args(3), &val6);
10144  if (!SWIG_IsOK(ecode6)) {
10145  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
10146  }
10147  arg6 = (PLFLT)(val6);
10148  ecode7 = SWIG_AsVal_double(args(4), &val7);
10149  if (!SWIG_IsOK(ecode7)) {
10150  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
10151  }
10152  arg7 = (PLFLT)(val7);
10153  ecode8 = SWIG_AsVal_double(args(5), &val8);
10154  if (!SWIG_IsOK(ecode8)) {
10155  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
10156  }
10157  arg8 = (PLFLT)(val8);
10158  ecode9 = SWIG_AsVal_double(args(6), &val9);
10159  if (!SWIG_IsOK(ecode9)) {
10160  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
10161  }
10162  arg9 = (PLFLT)(val9);
10163  ecode10 = SWIG_AsVal_double(args(7), &val10);
10164  if (!SWIG_IsOK(ecode10)) {
10165  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
10166  }
10167  arg10 = (PLFLT)(val10);
10168  ecode11 = SWIG_AsVal_int(args(8), &val11);
10169  if (!SWIG_IsOK(ecode11)) {
10170  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
10171  }
10172  arg11 = (PLINT)(val11);
10173  ecode12 = SWIG_AsVal_double(args(9), &val12);
10174  if (!SWIG_IsOK(ecode12)) {
10175  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
10176  }
10177  arg12 = (PLFLT)(val12);
10178  ecode13 = SWIG_AsVal_int(args(10), &val13);
10179  if (!SWIG_IsOK(ecode13)) {
10180  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
10181  }
10182  arg13 = (PLINT)(val13);
10183  ecode14 = SWIG_AsVal_int(args(11), &val14);
10184  if (!SWIG_IsOK(ecode14)) {
10185  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
10186  }
10187  arg14 = (PLINT)(val14);
10188  ecode15 = SWIG_AsVal_int(args(12), &val15);
10189  if (!SWIG_IsOK(ecode15)) {
10190  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
10191  }
10192  arg15 = (PLINT)(val15);
10193  ecode16 = SWIG_AsVal_int(args(13), &val16);
10194  if (!SWIG_IsOK(ecode16)) {
10195  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
10196  }
10197  arg16 = (PLINT)(val16);
10198  ecode17 = SWIG_AsVal_int(args(14), &val17);
10199  if (!SWIG_IsOK(ecode17)) {
10200  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
10201  }
10202  arg17 = (PLINT)(val17);
10203  ecode18 = SWIG_AsVal_int(args(15), &val18);
10204  if (!SWIG_IsOK(ecode18)) {
10205  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
10206  }
10207  arg18 = (PLBOOL)(val18);
10208  {
10209  if ( _n_dims( args(16) ) > 1 )
10210  {
10211  error( "argument must be a scalar or vector" ); SWIG_fail;
10212  }
10213  if ( _dim( args(16), 0 ) != Xlen )
10214  {
10215  error( "argument vectors must be same length" ); SWIG_fail;
10216  }
10217  temp19 = args(16).matrix_value();
10218  arg19 = &temp19( 0, 0 );
10219  }
10220  {
10221  if ( _n_dims( args(17) ) > 1 )
10222  {
10223  error( "argument must be a scalar or vector" ); SWIG_fail;
10224  }
10225  if ( _dim( args(17), 0 ) != Ylen )
10226  {
10227  error( "argument vectors must be same length" ); SWIG_fail;
10228  }
10229  temp20 = args(17).matrix_value();
10230  arg20 = &temp20( 0, 0 );
10231  }
10232  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);
10233  _outv = octave_value();
10234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10235  {
10236 
10237  }
10238  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10239  {
10240 
10241  }
10242  {
10243 
10244  }
10245 fail:
10246  return _out;
10247 }
10248 
10249 
10250 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
10251  PLFLT *arg1 = (PLFLT *) 0 ;
10252  PLINT arg2 ;
10253  PLINT arg3 ;
10254  char *arg4 = (char *) 0 ;
10255  PLFLT arg5 ;
10256  PLFLT arg6 ;
10257  PLFLT arg7 ;
10258  PLFLT arg8 ;
10259  PLFLT arg9 ;
10260  PLFLT arg10 ;
10261  PLINT arg11 ;
10262  PLFLT arg12 ;
10263  PLINT arg13 ;
10264  PLINT arg14 ;
10265  PLINT arg15 ;
10266  PLINT arg16 ;
10267  PLINT arg17 ;
10268  PLBOOL arg18 ;
10269  PLFLT *arg19 = (PLFLT *) 0 ;
10270  PLFLT *arg20 = (PLFLT *) 0 ;
10271  Matrix temp1 ;
10272  int res4 ;
10273  char *buf4 = 0 ;
10274  int alloc4 = 0 ;
10275  double val5 ;
10276  int ecode5 = 0 ;
10277  double val6 ;
10278  int ecode6 = 0 ;
10279  double val7 ;
10280  int ecode7 = 0 ;
10281  double val8 ;
10282  int ecode8 = 0 ;
10283  double val9 ;
10284  int ecode9 = 0 ;
10285  double val10 ;
10286  int ecode10 = 0 ;
10287  int val11 ;
10288  int ecode11 = 0 ;
10289  double val12 ;
10290  int ecode12 = 0 ;
10291  int val13 ;
10292  int ecode13 = 0 ;
10293  int val14 ;
10294  int ecode14 = 0 ;
10295  int val15 ;
10296  int ecode15 = 0 ;
10297  int val16 ;
10298  int ecode16 = 0 ;
10299  int val17 ;
10300  int ecode17 = 0 ;
10301  int val18 ;
10302  int ecode18 = 0 ;
10303  Matrix temp19 ;
10304  Matrix temp20 ;
10305  octave_value_list _out;
10306  octave_value_list *_outp=&_out;
10307  octave_value _outv;
10308 
10309  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
10310  SWIG_fail;
10311  }
10312  {
10313  if ( _n_dims( args(0) ) > 2 )
10314  {
10315  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10316  }
10317  temp1 = args(0).matrix_value();
10318  arg1 = &temp1( 0, 0 );
10319  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10320  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10321  }
10322  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10323  if (!SWIG_IsOK(res4)) {
10324  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
10325  }
10326  arg4 = (char *)(buf4);
10327  ecode5 = SWIG_AsVal_double(args(2), &val5);
10328  if (!SWIG_IsOK(ecode5)) {
10329  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
10330  }
10331  arg5 = (PLFLT)(val5);
10332  ecode6 = SWIG_AsVal_double(args(3), &val6);
10333  if (!SWIG_IsOK(ecode6)) {
10334  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
10335  }
10336  arg6 = (PLFLT)(val6);
10337  ecode7 = SWIG_AsVal_double(args(4), &val7);
10338  if (!SWIG_IsOK(ecode7)) {
10339  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
10340  }
10341  arg7 = (PLFLT)(val7);
10342  ecode8 = SWIG_AsVal_double(args(5), &val8);
10343  if (!SWIG_IsOK(ecode8)) {
10344  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
10345  }
10346  arg8 = (PLFLT)(val8);
10347  ecode9 = SWIG_AsVal_double(args(6), &val9);
10348  if (!SWIG_IsOK(ecode9)) {
10349  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
10350  }
10351  arg9 = (PLFLT)(val9);
10352  ecode10 = SWIG_AsVal_double(args(7), &val10);
10353  if (!SWIG_IsOK(ecode10)) {
10354  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
10355  }
10356  arg10 = (PLFLT)(val10);
10357  ecode11 = SWIG_AsVal_int(args(8), &val11);
10358  if (!SWIG_IsOK(ecode11)) {
10359  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
10360  }
10361  arg11 = (PLINT)(val11);
10362  ecode12 = SWIG_AsVal_double(args(9), &val12);
10363  if (!SWIG_IsOK(ecode12)) {
10364  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
10365  }
10366  arg12 = (PLFLT)(val12);
10367  ecode13 = SWIG_AsVal_int(args(10), &val13);
10368  if (!SWIG_IsOK(ecode13)) {
10369  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
10370  }
10371  arg13 = (PLINT)(val13);
10372  ecode14 = SWIG_AsVal_int(args(11), &val14);
10373  if (!SWIG_IsOK(ecode14)) {
10374  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
10375  }
10376  arg14 = (PLINT)(val14);
10377  ecode15 = SWIG_AsVal_int(args(12), &val15);
10378  if (!SWIG_IsOK(ecode15)) {
10379  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
10380  }
10381  arg15 = (PLINT)(val15);
10382  ecode16 = SWIG_AsVal_int(args(13), &val16);
10383  if (!SWIG_IsOK(ecode16)) {
10384  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
10385  }
10386  arg16 = (PLINT)(val16);
10387  ecode17 = SWIG_AsVal_int(args(14), &val17);
10388  if (!SWIG_IsOK(ecode17)) {
10389  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
10390  }
10391  arg17 = (PLINT)(val17);
10392  ecode18 = SWIG_AsVal_int(args(15), &val18);
10393  if (!SWIG_IsOK(ecode18)) {
10394  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
10395  }
10396  arg18 = (PLBOOL)(val18);
10397  {
10398  if ( _n_dims( args(16) ) > 2 )
10399  {
10400  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10401  }
10402  temp19 = args(16).matrix_value();
10403  arg19 = &temp19( 0, 0 );
10404  Xlen = (PLINT) ( _dim( args(16), 0 ) );
10405  Ylen = (PLINT) ( _dim( args(16), 1 ) );
10406  }
10407  {
10408  if ( _n_dims( args(17) ) > 2 )
10409  {
10410  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10411  }
10412  temp20 = args(17).matrix_value();
10413  arg20 = &temp20( 0, 0 );
10414  Xlen = (PLINT) ( _dim( args(17), 0 ) );
10415  Ylen = (PLINT) ( _dim( args(17), 1 ) );
10416  }
10417  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);
10418  _outv = octave_value();
10419  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10420  {
10421 
10422  }
10423  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10424  {
10425 
10426  }
10427  {
10428 
10429  }
10430 fail:
10431  return _out;
10432 }
10433 
10434 
10435 SWIG_DEFUN( plshades, _wrap_plshades, std::string() ) {
10436  PLFLT *arg1 = (PLFLT *) 0 ;
10437  PLINT arg2 ;
10438  PLINT arg3 ;
10439  PLFLT arg4 ;
10440  PLFLT arg5 ;
10441  PLFLT arg6 ;
10442  PLFLT arg7 ;
10443  PLFLT *arg8 = (PLFLT *) 0 ;
10444  PLINT arg9 ;
10445  PLINT arg10 ;
10446  PLINT arg11 ;
10447  PLINT arg12 ;
10448  PLBOOL arg13 ;
10449  Matrix temp1 ;
10450  double val4 ;
10451  int ecode4 = 0 ;
10452  double val5 ;
10453  int ecode5 = 0 ;
10454  double val6 ;
10455  int ecode6 = 0 ;
10456  double val7 ;
10457  int ecode7 = 0 ;
10458  Matrix temp8 ;
10459  int val10 ;
10460  int ecode10 = 0 ;
10461  int val11 ;
10462  int ecode11 = 0 ;
10463  int val12 ;
10464  int ecode12 = 0 ;
10465  int val13 ;
10466  int ecode13 = 0 ;
10467  octave_value_list _out;
10468  octave_value_list *_outp=&_out;
10469  octave_value _outv;
10470 
10471  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
10472  SWIG_fail;
10473  }
10474  {
10475  if ( _n_dims( args(0) ) > 2 )
10476  {
10477  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10478  }
10479  temp1 = args(0).matrix_value();
10480  arg1 = &temp1( 0, 0 );
10481  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10482  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10483  }
10484  ecode4 = SWIG_AsVal_double(args(1), &val4);
10485  if (!SWIG_IsOK(ecode4)) {
10486  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
10487  }
10488  arg4 = (PLFLT)(val4);
10489  ecode5 = SWIG_AsVal_double(args(2), &val5);
10490  if (!SWIG_IsOK(ecode5)) {
10491  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
10492  }
10493  arg5 = (PLFLT)(val5);
10494  ecode6 = SWIG_AsVal_double(args(3), &val6);
10495  if (!SWIG_IsOK(ecode6)) {
10496  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
10497  }
10498  arg6 = (PLFLT)(val6);
10499  ecode7 = SWIG_AsVal_double(args(4), &val7);
10500  if (!SWIG_IsOK(ecode7)) {
10501  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
10502  }
10503  arg7 = (PLFLT)(val7);
10504  {
10505  if ( _n_dims( args(5) ) > 1 )
10506  {
10507  error( "argument must be a scalar or vector" ); SWIG_fail;
10508  }
10509  temp8 = args(5).matrix_value();
10510  arg8 = &temp8( 0, 0 );
10511  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10512  }
10513  ecode10 = SWIG_AsVal_int(args(6), &val10);
10514  if (!SWIG_IsOK(ecode10)) {
10515  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
10516  }
10517  arg10 = (PLINT)(val10);
10518  ecode11 = SWIG_AsVal_int(args(7), &val11);
10519  if (!SWIG_IsOK(ecode11)) {
10520  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
10521  }
10522  arg11 = (PLINT)(val11);
10523  ecode12 = SWIG_AsVal_int(args(8), &val12);
10524  if (!SWIG_IsOK(ecode12)) {
10525  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
10526  }
10527  arg12 = (PLINT)(val12);
10528  ecode13 = SWIG_AsVal_int(args(9), &val13);
10529  if (!SWIG_IsOK(ecode13)) {
10530  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
10531  }
10532  arg13 = (PLBOOL)(val13);
10533  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
10534  _outv = octave_value();
10535  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10536  {
10537 
10538  }
10539  {
10540 
10541  }
10542 fail:
10543  return _out;
10544 }
10545 
10546 
10547 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
10548  PLFLT *arg1 = (PLFLT *) 0 ;
10549  PLINT arg2 ;
10550  PLINT arg3 ;
10551  PLFLT arg4 ;
10552  PLFLT arg5 ;
10553  PLFLT arg6 ;
10554  PLFLT arg7 ;
10555  PLFLT *arg8 = (PLFLT *) 0 ;
10556  PLINT arg9 ;
10557  PLINT arg10 ;
10558  PLINT arg11 ;
10559  PLINT arg12 ;
10560  PLBOOL arg13 ;
10561  PLFLT *arg14 = (PLFLT *) 0 ;
10562  Matrix temp1 ;
10563  double val4 ;
10564  int ecode4 = 0 ;
10565  double val5 ;
10566  int ecode5 = 0 ;
10567  double val6 ;
10568  int ecode6 = 0 ;
10569  double val7 ;
10570  int ecode7 = 0 ;
10571  Matrix temp8 ;
10572  int val10 ;
10573  int ecode10 = 0 ;
10574  int val11 ;
10575  int ecode11 = 0 ;
10576  int val12 ;
10577  int ecode12 = 0 ;
10578  int val13 ;
10579  int ecode13 = 0 ;
10580  Matrix temp14 ;
10581  octave_value_list _out;
10582  octave_value_list *_outp=&_out;
10583  octave_value _outv;
10584 
10585  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
10586  SWIG_fail;
10587  }
10588  {
10589  if ( _n_dims( args(0) ) > 2 )
10590  {
10591  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10592  }
10593  temp1 = args(0).matrix_value();
10594  arg1 = &temp1( 0, 0 );
10595  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10596  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10597  }
10598  ecode4 = SWIG_AsVal_double(args(1), &val4);
10599  if (!SWIG_IsOK(ecode4)) {
10600  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
10601  }
10602  arg4 = (PLFLT)(val4);
10603  ecode5 = SWIG_AsVal_double(args(2), &val5);
10604  if (!SWIG_IsOK(ecode5)) {
10605  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
10606  }
10607  arg5 = (PLFLT)(val5);
10608  ecode6 = SWIG_AsVal_double(args(3), &val6);
10609  if (!SWIG_IsOK(ecode6)) {
10610  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
10611  }
10612  arg6 = (PLFLT)(val6);
10613  ecode7 = SWIG_AsVal_double(args(4), &val7);
10614  if (!SWIG_IsOK(ecode7)) {
10615  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
10616  }
10617  arg7 = (PLFLT)(val7);
10618  {
10619  if ( _n_dims( args(5) ) > 1 )
10620  {
10621  error( "argument must be a scalar or vector" ); SWIG_fail;
10622  }
10623  temp8 = args(5).matrix_value();
10624  arg8 = &temp8( 0, 0 );
10625  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10626  }
10627  ecode10 = SWIG_AsVal_int(args(6), &val10);
10628  if (!SWIG_IsOK(ecode10)) {
10629  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
10630  }
10631  arg10 = (PLINT)(val10);
10632  ecode11 = SWIG_AsVal_int(args(7), &val11);
10633  if (!SWIG_IsOK(ecode11)) {
10634  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
10635  }
10636  arg11 = (PLINT)(val11);
10637  ecode12 = SWIG_AsVal_int(args(8), &val12);
10638  if (!SWIG_IsOK(ecode12)) {
10639  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
10640  }
10641  arg12 = (PLINT)(val12);
10642  ecode13 = SWIG_AsVal_int(args(9), &val13);
10643  if (!SWIG_IsOK(ecode13)) {
10644  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
10645  }
10646  arg13 = (PLBOOL)(val13);
10647  {
10648  if ( _n_dims( args(10) ) > 1 )
10649  {
10650  error( "argument must be a scalar or vector" ); SWIG_fail;
10651  }
10652  if ( _dim( args(10), 0 ) != 6 )
10653  {
10654  error( "argument vectors must have length of 6" ); SWIG_fail;
10655  }
10656  temp14 = args(10).matrix_value();
10657  arg14 = &temp14( 0, 0 );
10658  }
10659  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
10660  _outv = octave_value();
10661  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10662  {
10663 
10664  }
10665  {
10666 
10667  }
10668  {
10669 
10670  }
10671 fail:
10672  return _out;
10673 }
10674 
10675 
10676 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
10677  PLFLT *arg1 = (PLFLT *) 0 ;
10678  PLINT arg2 ;
10679  PLINT arg3 ;
10680  PLFLT arg4 ;
10681  PLFLT arg5 ;
10682  PLFLT arg6 ;
10683  PLFLT arg7 ;
10684  PLFLT *arg8 = (PLFLT *) 0 ;
10685  PLINT arg9 ;
10686  PLINT arg10 ;
10687  PLINT arg11 ;
10688  PLINT arg12 ;
10689  PLBOOL arg13 ;
10690  PLFLT *arg14 = (PLFLT *) 0 ;
10691  PLFLT *arg15 = (PLFLT *) 0 ;
10692  Matrix temp1 ;
10693  double val4 ;
10694  int ecode4 = 0 ;
10695  double val5 ;
10696  int ecode5 = 0 ;
10697  double val6 ;
10698  int ecode6 = 0 ;
10699  double val7 ;
10700  int ecode7 = 0 ;
10701  Matrix temp8 ;
10702  int val10 ;
10703  int ecode10 = 0 ;
10704  int val11 ;
10705  int ecode11 = 0 ;
10706  int val12 ;
10707  int ecode12 = 0 ;
10708  int val13 ;
10709  int ecode13 = 0 ;
10710  Matrix temp14 ;
10711  Matrix temp15 ;
10712  octave_value_list _out;
10713  octave_value_list *_outp=&_out;
10714  octave_value _outv;
10715 
10716  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
10717  SWIG_fail;
10718  }
10719  {
10720  if ( _n_dims( args(0) ) > 2 )
10721  {
10722  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10723  }
10724  temp1 = args(0).matrix_value();
10725  arg1 = &temp1( 0, 0 );
10726  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10727  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10728  }
10729  ecode4 = SWIG_AsVal_double(args(1), &val4);
10730  if (!SWIG_IsOK(ecode4)) {
10731  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
10732  }
10733  arg4 = (PLFLT)(val4);
10734  ecode5 = SWIG_AsVal_double(args(2), &val5);
10735  if (!SWIG_IsOK(ecode5)) {
10736  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
10737  }
10738  arg5 = (PLFLT)(val5);
10739  ecode6 = SWIG_AsVal_double(args(3), &val6);
10740  if (!SWIG_IsOK(ecode6)) {
10741  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
10742  }
10743  arg6 = (PLFLT)(val6);
10744  ecode7 = SWIG_AsVal_double(args(4), &val7);
10745  if (!SWIG_IsOK(ecode7)) {
10746  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
10747  }
10748  arg7 = (PLFLT)(val7);
10749  {
10750  if ( _n_dims( args(5) ) > 1 )
10751  {
10752  error( "argument must be a scalar or vector" ); SWIG_fail;
10753  }
10754  temp8 = args(5).matrix_value();
10755  arg8 = &temp8( 0, 0 );
10756  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10757  }
10758  ecode10 = SWIG_AsVal_int(args(6), &val10);
10759  if (!SWIG_IsOK(ecode10)) {
10760  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
10761  }
10762  arg10 = (PLINT)(val10);
10763  ecode11 = SWIG_AsVal_int(args(7), &val11);
10764  if (!SWIG_IsOK(ecode11)) {
10765  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
10766  }
10767  arg11 = (PLINT)(val11);
10768  ecode12 = SWIG_AsVal_int(args(8), &val12);
10769  if (!SWIG_IsOK(ecode12)) {
10770  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
10771  }
10772  arg12 = (PLINT)(val12);
10773  ecode13 = SWIG_AsVal_int(args(9), &val13);
10774  if (!SWIG_IsOK(ecode13)) {
10775  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
10776  }
10777  arg13 = (PLBOOL)(val13);
10778  {
10779  if ( _n_dims( args(10) ) > 1 )
10780  {
10781  error( "argument must be a scalar or vector" ); SWIG_fail;
10782  }
10783  if ( _dim( args(10), 0 ) != Xlen )
10784  {
10785  error( "argument vectors must be same length" ); SWIG_fail;
10786  }
10787  temp14 = args(10).matrix_value();
10788  arg14 = &temp14( 0, 0 );
10789  }
10790  {
10791  if ( _n_dims( args(11) ) > 1 )
10792  {
10793  error( "argument must be a scalar or vector" ); SWIG_fail;
10794  }
10795  if ( _dim( args(11), 0 ) != Ylen )
10796  {
10797  error( "argument vectors must be same length" ); SWIG_fail;
10798  }
10799  temp15 = args(11).matrix_value();
10800  arg15 = &temp15( 0, 0 );
10801  }
10802  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);
10803  _outv = octave_value();
10804  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10805  {
10806 
10807  }
10808  {
10809 
10810  }
10811  {
10812 
10813  }
10814  {
10815 
10816  }
10817 fail:
10818  return _out;
10819 }
10820 
10821 
10822 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
10823  PLFLT *arg1 = (PLFLT *) 0 ;
10824  PLINT arg2 ;
10825  PLINT arg3 ;
10826  PLFLT arg4 ;
10827  PLFLT arg5 ;
10828  PLFLT arg6 ;
10829  PLFLT arg7 ;
10830  PLFLT *arg8 = (PLFLT *) 0 ;
10831  PLINT arg9 ;
10832  PLINT arg10 ;
10833  PLINT arg11 ;
10834  PLINT arg12 ;
10835  PLBOOL arg13 ;
10836  PLFLT *arg14 = (PLFLT *) 0 ;
10837  PLFLT *arg15 = (PLFLT *) 0 ;
10838  Matrix temp1 ;
10839  double val4 ;
10840  int ecode4 = 0 ;
10841  double val5 ;
10842  int ecode5 = 0 ;
10843  double val6 ;
10844  int ecode6 = 0 ;
10845  double val7 ;
10846  int ecode7 = 0 ;
10847  Matrix temp8 ;
10848  int val10 ;
10849  int ecode10 = 0 ;
10850  int val11 ;
10851  int ecode11 = 0 ;
10852  int val12 ;
10853  int ecode12 = 0 ;
10854  int val13 ;
10855  int ecode13 = 0 ;
10856  Matrix temp14 ;
10857  Matrix temp15 ;
10858  octave_value_list _out;
10859  octave_value_list *_outp=&_out;
10860  octave_value _outv;
10861 
10862  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
10863  SWIG_fail;
10864  }
10865  {
10866  if ( _n_dims( args(0) ) > 2 )
10867  {
10868  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10869  }
10870  temp1 = args(0).matrix_value();
10871  arg1 = &temp1( 0, 0 );
10872  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10873  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10874  }
10875  ecode4 = SWIG_AsVal_double(args(1), &val4);
10876  if (!SWIG_IsOK(ecode4)) {
10877  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
10878  }
10879  arg4 = (PLFLT)(val4);
10880  ecode5 = SWIG_AsVal_double(args(2), &val5);
10881  if (!SWIG_IsOK(ecode5)) {
10882  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
10883  }
10884  arg5 = (PLFLT)(val5);
10885  ecode6 = SWIG_AsVal_double(args(3), &val6);
10886  if (!SWIG_IsOK(ecode6)) {
10887  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
10888  }
10889  arg6 = (PLFLT)(val6);
10890  ecode7 = SWIG_AsVal_double(args(4), &val7);
10891  if (!SWIG_IsOK(ecode7)) {
10892  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
10893  }
10894  arg7 = (PLFLT)(val7);
10895  {
10896  if ( _n_dims( args(5) ) > 1 )
10897  {
10898  error( "argument must be a scalar or vector" ); SWIG_fail;
10899  }
10900  temp8 = args(5).matrix_value();
10901  arg8 = &temp8( 0, 0 );
10902  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10903  }
10904  ecode10 = SWIG_AsVal_int(args(6), &val10);
10905  if (!SWIG_IsOK(ecode10)) {
10906  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
10907  }
10908  arg10 = (PLINT)(val10);
10909  ecode11 = SWIG_AsVal_int(args(7), &val11);
10910  if (!SWIG_IsOK(ecode11)) {
10911  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
10912  }
10913  arg11 = (PLINT)(val11);
10914  ecode12 = SWIG_AsVal_int(args(8), &val12);
10915  if (!SWIG_IsOK(ecode12)) {
10916  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
10917  }
10918  arg12 = (PLINT)(val12);
10919  ecode13 = SWIG_AsVal_int(args(9), &val13);
10920  if (!SWIG_IsOK(ecode13)) {
10921  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
10922  }
10923  arg13 = (PLBOOL)(val13);
10924  {
10925  if ( _n_dims( args(10) ) > 2 )
10926  {
10927  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10928  }
10929  temp14 = args(10).matrix_value();
10930  arg14 = &temp14( 0, 0 );
10931  Xlen = (PLINT) ( _dim( args(10), 0 ) );
10932  Ylen = (PLINT) ( _dim( args(10), 1 ) );
10933  }
10934  {
10935  if ( _n_dims( args(11) ) > 2 )
10936  {
10937  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10938  }
10939  temp15 = args(11).matrix_value();
10940  arg15 = &temp15( 0, 0 );
10941  Xlen = (PLINT) ( _dim( args(11), 0 ) );
10942  Ylen = (PLINT) ( _dim( args(11), 1 ) );
10943  }
10944  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);
10945  _outv = octave_value();
10946  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10947  {
10948 
10949  }
10950  {
10951 
10952  }
10953  {
10954 
10955  }
10956  {
10957 
10958  }
10959 fail:
10960  return _out;
10961 }
10962 
10963 
10964 SWIG_DEFUN( plvect, _wrap_plvect, std::string() ) {
10965  PLFLT *arg1 = (PLFLT *) 0 ;
10966  PLFLT *arg2 = (PLFLT *) 0 ;
10967  PLINT arg3 ;
10968  PLINT arg4 ;
10969  PLFLT arg5 ;
10970  PLFLT *arg6 = (PLFLT *) 0 ;
10971  Matrix temp1 ;
10972  Matrix temp2 ;
10973  double val5 ;
10974  int ecode5 = 0 ;
10975  Matrix temp6 ;
10976  octave_value_list _out;
10977  octave_value_list *_outp=&_out;
10978  octave_value _outv;
10979 
10980  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
10981  SWIG_fail;
10982  }
10983  {
10984  if ( _n_dims( args(0) ) > 2 )
10985  {
10986  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10987  }
10988  temp1 = args(0).matrix_value();
10989  arg1 = &temp1( 0, 0 );
10990  Xlen = (PLINT) ( _dim( args(0), 0 ) );
10991  Ylen = (PLINT) ( _dim( args(0), 1 ) );
10992  }
10993  {
10994  if ( _n_dims( args(1) ) > 2 )
10995  {
10996  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10997  }
10998  if ( _dim( args(1), 0 ) != Xlen )
10999  {
11000  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11001  }
11002  if ( _dim( args(1), 1 ) != Ylen )
11003  {
11004  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11005  }
11006  temp2 = args(1).matrix_value();
11007  arg2 = &temp2( 0, 0 );
11008  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11009  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11010  }
11011  ecode5 = SWIG_AsVal_double(args(2), &val5);
11012  if (!SWIG_IsOK(ecode5)) {
11013  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
11014  }
11015  arg5 = (PLFLT)(val5);
11016  {
11017  if ( _n_dims( args(3) ) > 1 )
11018  {
11019  error( "argument must be a scalar or vector" ); SWIG_fail;
11020  }
11021  if ( _dim( args(3), 0 ) != 6 )
11022  {
11023  error( "argument vectors must have length of 6" ); SWIG_fail;
11024  }
11025  temp6 = args(3).matrix_value();
11026  arg6 = &temp6( 0, 0 );
11027  }
11028  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
11029  _outv = octave_value();
11030  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11031  {
11032 
11033  }
11034  {
11035 
11036  }
11037  {
11038 
11039  }
11040 fail:
11041  return _out;
11042 }
11043 
11044 
11045 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
11046  PLFLT *arg1 = (PLFLT *) 0 ;
11047  PLFLT *arg2 = (PLFLT *) 0 ;
11048  PLINT arg3 ;
11049  PLINT arg4 ;
11050  PLFLT arg5 ;
11051  PLFLT *arg6 = (PLFLT *) 0 ;
11052  PLFLT *arg7 = (PLFLT *) 0 ;
11053  Matrix temp1 ;
11054  Matrix temp2 ;
11055  double val5 ;
11056  int ecode5 = 0 ;
11057  Matrix temp6 ;
11058  Matrix temp7 ;
11059  octave_value_list _out;
11060  octave_value_list *_outp=&_out;
11061  octave_value _outv;
11062 
11063  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
11064  SWIG_fail;
11065  }
11066  {
11067  if ( _n_dims( args(0) ) > 2 )
11068  {
11069  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11070  }
11071  temp1 = args(0).matrix_value();
11072  arg1 = &temp1( 0, 0 );
11073  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11074  Ylen = (PLINT) ( _dim( args(0), 1 ) );
11075  }
11076  {
11077  if ( _n_dims( args(1) ) > 2 )
11078  {
11079  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11080  }
11081  if ( _dim( args(1), 0 ) != Xlen )
11082  {
11083  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11084  }
11085  if ( _dim( args(1), 1 ) != Ylen )
11086  {
11087  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11088  }
11089  temp2 = args(1).matrix_value();
11090  arg2 = &temp2( 0, 0 );
11091  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11092  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11093  }
11094  ecode5 = SWIG_AsVal_double(args(2), &val5);
11095  if (!SWIG_IsOK(ecode5)) {
11096  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
11097  }
11098  arg5 = (PLFLT)(val5);
11099  {
11100  if ( _n_dims( args(3) ) > 1 )
11101  {
11102  error( "argument must be a scalar or vector" ); SWIG_fail;
11103  }
11104  if ( _dim( args(3), 0 ) != Xlen )
11105  {
11106  error( "argument vectors must be same length" ); SWIG_fail;
11107  }
11108  temp6 = args(3).matrix_value();
11109  arg6 = &temp6( 0, 0 );
11110  }
11111  {
11112  if ( _n_dims( args(4) ) > 1 )
11113  {
11114  error( "argument must be a scalar or vector" ); SWIG_fail;
11115  }
11116  if ( _dim( args(4), 0 ) != Ylen )
11117  {
11118  error( "argument vectors must be same length" ); SWIG_fail;
11119  }
11120  temp7 = args(4).matrix_value();
11121  arg7 = &temp7( 0, 0 );
11122  }
11123  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
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  {
11136 
11137  }
11138 fail:
11139  return _out;
11140 }
11141 
11142 
11143 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
11144  PLFLT *arg1 = (PLFLT *) 0 ;
11145  PLFLT *arg2 = (PLFLT *) 0 ;
11146  PLINT arg3 ;
11147  PLINT arg4 ;
11148  PLFLT arg5 ;
11149  PLFLT *arg6 = (PLFLT *) 0 ;
11150  PLFLT *arg7 = (PLFLT *) 0 ;
11151  Matrix temp1 ;
11152  Matrix temp2 ;
11153  double val5 ;
11154  int ecode5 = 0 ;
11155  Matrix temp6 ;
11156  Matrix temp7 ;
11157  octave_value_list _out;
11158  octave_value_list *_outp=&_out;
11159  octave_value _outv;
11160 
11161  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
11162  SWIG_fail;
11163  }
11164  {
11165  if ( _n_dims( args(0) ) > 2 )
11166  {
11167  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11168  }
11169  temp1 = args(0).matrix_value();
11170  arg1 = &temp1( 0, 0 );
11171  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11172  Ylen = (PLINT) ( _dim( args(0), 1 ) );
11173  }
11174  {
11175  if ( _n_dims( args(1) ) > 2 )
11176  {
11177  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11178  }
11179  if ( _dim( args(1), 0 ) != Xlen )
11180  {
11181  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11182  }
11183  if ( _dim( args(1), 1 ) != Ylen )
11184  {
11185  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11186  }
11187  temp2 = args(1).matrix_value();
11188  arg2 = &temp2( 0, 0 );
11189  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11190  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11191  }
11192  ecode5 = SWIG_AsVal_double(args(2), &val5);
11193  if (!SWIG_IsOK(ecode5)) {
11194  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
11195  }
11196  arg5 = (PLFLT)(val5);
11197  {
11198  if ( _n_dims( args(3) ) > 2 )
11199  {
11200  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11201  }
11202  temp6 = args(3).matrix_value();
11203  arg6 = &temp6( 0, 0 );
11204  Xlen = (PLINT) ( _dim( args(3), 0 ) );
11205  Ylen = (PLINT) ( _dim( args(3), 1 ) );
11206  }
11207  {
11208  if ( _n_dims( args(4) ) > 2 )
11209  {
11210  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11211  }
11212  temp7 = args(4).matrix_value();
11213  arg7 = &temp7( 0, 0 );
11214  Xlen = (PLINT) ( _dim( args(4), 0 ) );
11215  Ylen = (PLINT) ( _dim( args(4), 1 ) );
11216  }
11217  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
11218  _outv = octave_value();
11219  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11220  {
11221 
11222  }
11223  {
11224 
11225  }
11226  {
11227 
11228  }
11229  {
11230 
11231  }
11232 fail:
11233  return _out;
11234 }
11235 
11236 
11237 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
11238  PLFLT *arg1 = (PLFLT *) 0 ;
11239  PLINT arg2 ;
11240  PLINT arg3 ;
11241  PLFLT arg4 ;
11242  PLFLT arg5 ;
11243  PLFLT arg6 ;
11244  PLFLT arg7 ;
11245  PLFLT arg8 ;
11246  PLFLT arg9 ;
11247  PLFLT arg10 ;
11248  PLFLT arg11 ;
11249  PLFLT arg12 ;
11250  PLFLT arg13 ;
11251  Matrix temp1 ;
11252  double val4 ;
11253  int ecode4 = 0 ;
11254  double val5 ;
11255  int ecode5 = 0 ;
11256  double val6 ;
11257  int ecode6 = 0 ;
11258  double val7 ;
11259  int ecode7 = 0 ;
11260  double val8 ;
11261  int ecode8 = 0 ;
11262  double val9 ;
11263  int ecode9 = 0 ;
11264  double val10 ;
11265  int ecode10 = 0 ;
11266  double val11 ;
11267  int ecode11 = 0 ;
11268  double val12 ;
11269  int ecode12 = 0 ;
11270  double val13 ;
11271  int ecode13 = 0 ;
11272  octave_value_list _out;
11273  octave_value_list *_outp=&_out;
11274  octave_value _outv;
11275 
11276  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
11277  SWIG_fail;
11278  }
11279  {
11280  if ( _n_dims( args(0) ) > 2 )
11281  {
11282  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11283  }
11284  temp1 = args(0).matrix_value();
11285  arg1 = &temp1( 0, 0 );
11286  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11287  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11288  }
11289  ecode4 = SWIG_AsVal_double(args(1), &val4);
11290  if (!SWIG_IsOK(ecode4)) {
11291  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
11292  }
11293  arg4 = (PLFLT)(val4);
11294  ecode5 = SWIG_AsVal_double(args(2), &val5);
11295  if (!SWIG_IsOK(ecode5)) {
11296  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
11297  }
11298  arg5 = (PLFLT)(val5);
11299  ecode6 = SWIG_AsVal_double(args(3), &val6);
11300  if (!SWIG_IsOK(ecode6)) {
11301  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
11302  }
11303  arg6 = (PLFLT)(val6);
11304  ecode7 = SWIG_AsVal_double(args(4), &val7);
11305  if (!SWIG_IsOK(ecode7)) {
11306  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
11307  }
11308  arg7 = (PLFLT)(val7);
11309  ecode8 = SWIG_AsVal_double(args(5), &val8);
11310  if (!SWIG_IsOK(ecode8)) {
11311  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
11312  }
11313  arg8 = (PLFLT)(val8);
11314  ecode9 = SWIG_AsVal_double(args(6), &val9);
11315  if (!SWIG_IsOK(ecode9)) {
11316  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
11317  }
11318  arg9 = (PLFLT)(val9);
11319  ecode10 = SWIG_AsVal_double(args(7), &val10);
11320  if (!SWIG_IsOK(ecode10)) {
11321  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
11322  }
11323  arg10 = (PLFLT)(val10);
11324  ecode11 = SWIG_AsVal_double(args(8), &val11);
11325  if (!SWIG_IsOK(ecode11)) {
11326  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
11327  }
11328  arg11 = (PLFLT)(val11);
11329  ecode12 = SWIG_AsVal_double(args(9), &val12);
11330  if (!SWIG_IsOK(ecode12)) {
11331  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
11332  }
11333  arg12 = (PLFLT)(val12);
11334  ecode13 = SWIG_AsVal_double(args(10), &val13);
11335  if (!SWIG_IsOK(ecode13)) {
11336  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
11337  }
11338  arg13 = (PLFLT)(val13);
11339  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
11340  _outv = octave_value();
11341  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11342  {
11343 
11344  }
11345 fail:
11346  return _out;
11347 }
11348 
11349 
11351  PLFLT *arg1 = (PLFLT *) 0 ;
11352  PLINT arg2 ;
11353  PLINT arg3 ;
11354  PLFLT arg4 ;
11355  PLFLT arg5 ;
11356  PLFLT arg6 ;
11357  PLFLT arg7 ;
11358  PLFLT arg8 ;
11359  PLFLT arg9 ;
11360  PLFLT arg10 ;
11361  PLFLT arg11 ;
11362  Matrix temp1 ;
11363  double val4 ;
11364  int ecode4 = 0 ;
11365  double val5 ;
11366  int ecode5 = 0 ;
11367  double val6 ;
11368  int ecode6 = 0 ;
11369  double val7 ;
11370  int ecode7 = 0 ;
11371  double val8 ;
11372  int ecode8 = 0 ;
11373  double val9 ;
11374  int ecode9 = 0 ;
11375  double val10 ;
11376  int ecode10 = 0 ;
11377  double val11 ;
11378  int ecode11 = 0 ;
11379  octave_value_list _out;
11380  octave_value_list *_outp=&_out;
11381  octave_value _outv;
11382 
11383  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
11384  SWIG_fail;
11385  }
11386  {
11387  if ( _n_dims( args(0) ) > 2 )
11388  {
11389  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11390  }
11391  temp1 = args(0).matrix_value();
11392  arg1 = &temp1( 0, 0 );
11393  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11394  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11395  }
11396  ecode4 = SWIG_AsVal_double(args(1), &val4);
11397  if (!SWIG_IsOK(ecode4)) {
11398  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
11399  }
11400  arg4 = (PLFLT)(val4);
11401  ecode5 = SWIG_AsVal_double(args(2), &val5);
11402  if (!SWIG_IsOK(ecode5)) {
11403  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
11404  }
11405  arg5 = (PLFLT)(val5);
11406  ecode6 = SWIG_AsVal_double(args(3), &val6);
11407  if (!SWIG_IsOK(ecode6)) {
11408  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
11409  }
11410  arg6 = (PLFLT)(val6);
11411  ecode7 = SWIG_AsVal_double(args(4), &val7);
11412  if (!SWIG_IsOK(ecode7)) {
11413  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
11414  }
11415  arg7 = (PLFLT)(val7);
11416  ecode8 = SWIG_AsVal_double(args(5), &val8);
11417  if (!SWIG_IsOK(ecode8)) {
11418  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
11419  }
11420  arg8 = (PLFLT)(val8);
11421  ecode9 = SWIG_AsVal_double(args(6), &val9);
11422  if (!SWIG_IsOK(ecode9)) {
11423  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
11424  }
11425  arg9 = (PLFLT)(val9);
11426  ecode10 = SWIG_AsVal_double(args(7), &val10);
11427  if (!SWIG_IsOK(ecode10)) {
11428  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
11429  }
11430  arg10 = (PLFLT)(val10);
11431  ecode11 = SWIG_AsVal_double(args(8), &val11);
11432  if (!SWIG_IsOK(ecode11)) {
11433  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
11434  }
11435  arg11 = (PLFLT)(val11);
11436  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11437  _outv = octave_value();
11438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11439  {
11440 
11441  }
11442 fail:
11443  return _out;
11444 }
11445 
11446 
11447 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
11448  PLFLT *arg1 = (PLFLT *) 0 ;
11449  PLINT arg2 ;
11450  PLINT arg3 ;
11451  PLFLT arg4 ;
11452  PLFLT arg5 ;
11453  PLFLT arg6 ;
11454  PLFLT arg7 ;
11455  PLFLT arg8 ;
11456  PLFLT arg9 ;
11457  PLFLT arg10 ;
11458  PLFLT arg11 ;
11459  PLFLT *arg12 = (PLFLT *) 0 ;
11460  Matrix temp1 ;
11461  double val4 ;
11462  int ecode4 = 0 ;
11463  double val5 ;
11464  int ecode5 = 0 ;
11465  double val6 ;
11466  int ecode6 = 0 ;
11467  double val7 ;
11468  int ecode7 = 0 ;
11469  double val8 ;
11470  int ecode8 = 0 ;
11471  double val9 ;
11472  int ecode9 = 0 ;
11473  double val10 ;
11474  int ecode10 = 0 ;
11475  double val11 ;
11476  int ecode11 = 0 ;
11477  Matrix temp12 ;
11478  octave_value_list _out;
11479  octave_value_list *_outp=&_out;
11480  octave_value _outv;
11481 
11482  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
11483  SWIG_fail;
11484  }
11485  {
11486  if ( _n_dims( args(0) ) > 2 )
11487  {
11488  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11489  }
11490  temp1 = args(0).matrix_value();
11491  arg1 = &temp1( 0, 0 );
11492  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11493  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11494  }
11495  ecode4 = SWIG_AsVal_double(args(1), &val4);
11496  if (!SWIG_IsOK(ecode4)) {
11497  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
11498  }
11499  arg4 = (PLFLT)(val4);
11500  ecode5 = SWIG_AsVal_double(args(2), &val5);
11501  if (!SWIG_IsOK(ecode5)) {
11502  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
11503  }
11504  arg5 = (PLFLT)(val5);
11505  ecode6 = SWIG_AsVal_double(args(3), &val6);
11506  if (!SWIG_IsOK(ecode6)) {
11507  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
11508  }
11509  arg6 = (PLFLT)(val6);
11510  ecode7 = SWIG_AsVal_double(args(4), &val7);
11511  if (!SWIG_IsOK(ecode7)) {
11512  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
11513  }
11514  arg7 = (PLFLT)(val7);
11515  ecode8 = SWIG_AsVal_double(args(5), &val8);
11516  if (!SWIG_IsOK(ecode8)) {
11517  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
11518  }
11519  arg8 = (PLFLT)(val8);
11520  ecode9 = SWIG_AsVal_double(args(6), &val9);
11521  if (!SWIG_IsOK(ecode9)) {
11522  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
11523  }
11524  arg9 = (PLFLT)(val9);
11525  ecode10 = SWIG_AsVal_double(args(7), &val10);
11526  if (!SWIG_IsOK(ecode10)) {
11527  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
11528  }
11529  arg10 = (PLFLT)(val10);
11530  ecode11 = SWIG_AsVal_double(args(8), &val11);
11531  if (!SWIG_IsOK(ecode11)) {
11532  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
11533  }
11534  arg11 = (PLFLT)(val11);
11535  {
11536  if ( _n_dims( args(9) ) > 1 )
11537  {
11538  error( "argument must be a scalar or vector" ); SWIG_fail;
11539  }
11540  if ( _dim( args(9), 0 ) != 6 )
11541  {
11542  error( "argument vectors must have length of 6" ); SWIG_fail;
11543  }
11544  temp12 = args(9).matrix_value();
11545  arg12 = &temp12( 0, 0 );
11546  }
11547  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
11548  _outv = octave_value();
11549  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11550  {
11551 
11552  }
11553  {
11554 
11555  }
11556 fail:
11557  return _out;
11558 }
11559 
11560 
11561 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
11562  PLFLT *arg1 = (PLFLT *) 0 ;
11563  PLINT arg2 ;
11564  PLINT arg3 ;
11565  PLFLT arg4 ;
11566  PLFLT arg5 ;
11567  PLFLT arg6 ;
11568  PLFLT arg7 ;
11569  PLFLT arg8 ;
11570  PLFLT arg9 ;
11571  PLFLT arg10 ;
11572  PLFLT arg11 ;
11573  PLFLT *arg12 = (PLFLT *) 0 ;
11574  PLFLT *arg13 = (PLFLT *) 0 ;
11575  Matrix temp1 ;
11576  double val4 ;
11577  int ecode4 = 0 ;
11578  double val5 ;
11579  int ecode5 = 0 ;
11580  double val6 ;
11581  int ecode6 = 0 ;
11582  double val7 ;
11583  int ecode7 = 0 ;
11584  double val8 ;
11585  int ecode8 = 0 ;
11586  double val9 ;
11587  int ecode9 = 0 ;
11588  double val10 ;
11589  int ecode10 = 0 ;
11590  double val11 ;
11591  int ecode11 = 0 ;
11592  Matrix temp12 ;
11593  Matrix temp13 ;
11594  octave_value_list _out;
11595  octave_value_list *_outp=&_out;
11596  octave_value _outv;
11597 
11598  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
11599  SWIG_fail;
11600  }
11601  {
11602  if ( _n_dims( args(0) ) > 2 )
11603  {
11604  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11605  }
11606  temp1 = args(0).matrix_value();
11607  arg1 = &temp1( 0, 0 );
11608  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11609  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11610  }
11611  ecode4 = SWIG_AsVal_double(args(1), &val4);
11612  if (!SWIG_IsOK(ecode4)) {
11613  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
11614  }
11615  arg4 = (PLFLT)(val4);
11616  ecode5 = SWIG_AsVal_double(args(2), &val5);
11617  if (!SWIG_IsOK(ecode5)) {
11618  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
11619  }
11620  arg5 = (PLFLT)(val5);
11621  ecode6 = SWIG_AsVal_double(args(3), &val6);
11622  if (!SWIG_IsOK(ecode6)) {
11623  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
11624  }
11625  arg6 = (PLFLT)(val6);
11626  ecode7 = SWIG_AsVal_double(args(4), &val7);
11627  if (!SWIG_IsOK(ecode7)) {
11628  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
11629  }
11630  arg7 = (PLFLT)(val7);
11631  ecode8 = SWIG_AsVal_double(args(5), &val8);
11632  if (!SWIG_IsOK(ecode8)) {
11633  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
11634  }
11635  arg8 = (PLFLT)(val8);
11636  ecode9 = SWIG_AsVal_double(args(6), &val9);
11637  if (!SWIG_IsOK(ecode9)) {
11638  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
11639  }
11640  arg9 = (PLFLT)(val9);
11641  ecode10 = SWIG_AsVal_double(args(7), &val10);
11642  if (!SWIG_IsOK(ecode10)) {
11643  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
11644  }
11645  arg10 = (PLFLT)(val10);
11646  ecode11 = SWIG_AsVal_double(args(8), &val11);
11647  if (!SWIG_IsOK(ecode11)) {
11648  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
11649  }
11650  arg11 = (PLFLT)(val11);
11651  {
11652  if ( _n_dims( args(9) ) > 1 )
11653  {
11654  error( "argument must be a scalar or vector" ); SWIG_fail;
11655  }
11656  if ( _dim( args(9), 0 ) != Xlen )
11657  {
11658  error( "argument vectors must be same length" ); SWIG_fail;
11659  }
11660  temp12 = args(9).matrix_value();
11661  arg12 = &temp12( 0, 0 );
11662  }
11663  {
11664  if ( _n_dims( args(10) ) > 1 )
11665  {
11666  error( "argument must be a scalar or vector" ); SWIG_fail;
11667  }
11668  if ( _dim( args(10), 0 ) != Ylen )
11669  {
11670  error( "argument vectors must be same length" ); SWIG_fail;
11671  }
11672  temp13 = args(10).matrix_value();
11673  arg13 = &temp13( 0, 0 );
11674  }
11675  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
11676  _outv = octave_value();
11677  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11678  {
11679 
11680  }
11681  {
11682 
11683  }
11684  {
11685 
11686  }
11687 fail:
11688  return _out;
11689 }
11690 
11691 
11692 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
11693  PLFLT *arg1 = (PLFLT *) 0 ;
11694  PLINT arg2 ;
11695  PLINT arg3 ;
11696  PLFLT arg4 ;
11697  PLFLT arg5 ;
11698  PLFLT arg6 ;
11699  PLFLT arg7 ;
11700  PLFLT arg8 ;
11701  PLFLT arg9 ;
11702  PLFLT arg10 ;
11703  PLFLT arg11 ;
11704  PLFLT *arg12 = (PLFLT *) 0 ;
11705  PLFLT *arg13 = (PLFLT *) 0 ;
11706  Matrix temp1 ;
11707  double val4 ;
11708  int ecode4 = 0 ;
11709  double val5 ;
11710  int ecode5 = 0 ;
11711  double val6 ;
11712  int ecode6 = 0 ;
11713  double val7 ;
11714  int ecode7 = 0 ;
11715  double val8 ;
11716  int ecode8 = 0 ;
11717  double val9 ;
11718  int ecode9 = 0 ;
11719  double val10 ;
11720  int ecode10 = 0 ;
11721  double val11 ;
11722  int ecode11 = 0 ;
11723  Matrix temp12 ;
11724  Matrix temp13 ;
11725  octave_value_list _out;
11726  octave_value_list *_outp=&_out;
11727  octave_value _outv;
11728 
11729  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
11730  SWIG_fail;
11731  }
11732  {
11733  if ( _n_dims( args(0) ) > 2 )
11734  {
11735  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11736  }
11737  temp1 = args(0).matrix_value();
11738  arg1 = &temp1( 0, 0 );
11739  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11740  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11741  }
11742  ecode4 = SWIG_AsVal_double(args(1), &val4);
11743  if (!SWIG_IsOK(ecode4)) {
11744  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
11745  }
11746  arg4 = (PLFLT)(val4);
11747  ecode5 = SWIG_AsVal_double(args(2), &val5);
11748  if (!SWIG_IsOK(ecode5)) {
11749  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
11750  }
11751  arg5 = (PLFLT)(val5);
11752  ecode6 = SWIG_AsVal_double(args(3), &val6);
11753  if (!SWIG_IsOK(ecode6)) {
11754  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
11755  }
11756  arg6 = (PLFLT)(val6);
11757  ecode7 = SWIG_AsVal_double(args(4), &val7);
11758  if (!SWIG_IsOK(ecode7)) {
11759  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
11760  }
11761  arg7 = (PLFLT)(val7);
11762  ecode8 = SWIG_AsVal_double(args(5), &val8);
11763  if (!SWIG_IsOK(ecode8)) {
11764  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
11765  }
11766  arg8 = (PLFLT)(val8);
11767  ecode9 = SWIG_AsVal_double(args(6), &val9);
11768  if (!SWIG_IsOK(ecode9)) {
11769  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
11770  }
11771  arg9 = (PLFLT)(val9);
11772  ecode10 = SWIG_AsVal_double(args(7), &val10);
11773  if (!SWIG_IsOK(ecode10)) {
11774  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
11775  }
11776  arg10 = (PLFLT)(val10);
11777  ecode11 = SWIG_AsVal_double(args(8), &val11);
11778  if (!SWIG_IsOK(ecode11)) {
11779  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
11780  }
11781  arg11 = (PLFLT)(val11);
11782  {
11783  if ( _n_dims( args(9) ) > 2 )
11784  {
11785  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11786  }
11787  temp12 = args(9).matrix_value();
11788  arg12 = &temp12( 0, 0 );
11789  Xlen = (PLINT) ( _dim( args(9), 0 ) );
11790  Ylen = (PLINT) ( _dim( args(9), 1 ) );
11791  }
11792  {
11793  if ( _n_dims( args(10) ) > 2 )
11794  {
11795  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11796  }
11797  temp13 = args(10).matrix_value();
11798  arg13 = &temp13( 0, 0 );
11799  Xlen = (PLINT) ( _dim( args(10), 0 ) );
11800  Ylen = (PLINT) ( _dim( args(10), 1 ) );
11801  }
11802  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
11803  _outv = octave_value();
11804  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11805  {
11806 
11807  }
11808  {
11809 
11810  }
11811  {
11812 
11813  }
11814 fail:
11815  return _out;
11816 }
11817 
11818 
11820  PLFLT *arg1 = (PLFLT *) 0 ;
11821  PLFLT *arg2 = (PLFLT *) 0 ;
11822  PLINT arg3 ;
11823  PLINT arg4 ;
11824  PLFLT arg5 ;
11825  PLFLT arg6 ;
11826  PLFLT arg7 ;
11827  PLFLT arg8 ;
11828  PLINT arg9 ;
11829  PLINT arg10 ;
11830  PLINT arg11 ;
11831  PLFLT arg12 ;
11832  PLFLT arg13 ;
11833  PLINT arg14 ;
11834  PLFLT arg15 ;
11835  PLINT arg16 ;
11836  PLINT *arg17 = (PLINT *) 0 ;
11837  char **arg18 = (char **) 0 ;
11838  PLINT arg19 ;
11839  char **arg20 = (char **) 0 ;
11840  PLFLT *arg21 = (PLFLT *) 0 ;
11841  PLINT *arg22 = (PLINT *) 0 ;
11842  PLINT *arg23 = (PLINT *) 0 ;
11843  PLFLT *arg24 = (PLFLT *) 0 ;
11844  PLFLT temp1 ;
11845  int res1 = SWIG_TMPOBJ ;
11846  PLFLT temp2 ;
11847  int res2 = SWIG_TMPOBJ ;
11848  int val3 ;
11849  int ecode3 = 0 ;
11850  int val4 ;
11851  int ecode4 = 0 ;
11852  double val5 ;
11853  int ecode5 = 0 ;
11854  double val6 ;
11855  int ecode6 = 0 ;
11856  double val7 ;
11857  int ecode7 = 0 ;
11858  double val8 ;
11859  int ecode8 = 0 ;
11860  int val9 ;
11861  int ecode9 = 0 ;
11862  int val10 ;
11863  int ecode10 = 0 ;
11864  int val11 ;
11865  int ecode11 = 0 ;
11866  double val12 ;
11867  int ecode12 = 0 ;
11868  double val13 ;
11869  int ecode13 = 0 ;
11870  int val14 ;
11871  int ecode14 = 0 ;
11872  double val15 ;
11873  int ecode15 = 0 ;
11874  Matrix temp16 ;
11875  Matrix temp21 ;
11876  Matrix temp22 ;
11877  Matrix temp23 ;
11878  Matrix temp24 ;
11879  octave_value_list _out;
11880  octave_value_list *_outp=&_out;
11881  octave_value _outv;
11882 
11883  arg1 = &temp1;
11884  arg2 = &temp2;
11885  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
11886  SWIG_fail;
11887  }
11888  ecode3 = SWIG_AsVal_int(args(0), &val3);
11889  if (!SWIG_IsOK(ecode3)) {
11890  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
11891  }
11892  arg3 = (PLINT)(val3);
11893  ecode4 = SWIG_AsVal_int(args(1), &val4);
11894  if (!SWIG_IsOK(ecode4)) {
11895  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
11896  }
11897  arg4 = (PLINT)(val4);
11898  ecode5 = SWIG_AsVal_double(args(2), &val5);
11899  if (!SWIG_IsOK(ecode5)) {
11900  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
11901  }
11902  arg5 = (PLFLT)(val5);
11903  ecode6 = SWIG_AsVal_double(args(3), &val6);
11904  if (!SWIG_IsOK(ecode6)) {
11905  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
11906  }
11907  arg6 = (PLFLT)(val6);
11908  ecode7 = SWIG_AsVal_double(args(4), &val7);
11909  if (!SWIG_IsOK(ecode7)) {
11910  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
11911  }
11912  arg7 = (PLFLT)(val7);
11913  ecode8 = SWIG_AsVal_double(args(5), &val8);
11914  if (!SWIG_IsOK(ecode8)) {
11915  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
11916  }
11917  arg8 = (PLFLT)(val8);
11918  ecode9 = SWIG_AsVal_int(args(6), &val9);
11919  if (!SWIG_IsOK(ecode9)) {
11920  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
11921  }
11922  arg9 = (PLINT)(val9);
11923  ecode10 = SWIG_AsVal_int(args(7), &val10);
11924  if (!SWIG_IsOK(ecode10)) {
11925  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
11926  }
11927  arg10 = (PLINT)(val10);
11928  ecode11 = SWIG_AsVal_int(args(8), &val11);
11929  if (!SWIG_IsOK(ecode11)) {
11930  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
11931  }
11932  arg11 = (PLINT)(val11);
11933  ecode12 = SWIG_AsVal_double(args(9), &val12);
11934  if (!SWIG_IsOK(ecode12)) {
11935  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
11936  }
11937  arg12 = (PLFLT)(val12);
11938  ecode13 = SWIG_AsVal_double(args(10), &val13);
11939  if (!SWIG_IsOK(ecode13)) {
11940  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
11941  }
11942  arg13 = (PLFLT)(val13);
11943  ecode14 = SWIG_AsVal_int(args(11), &val14);
11944  if (!SWIG_IsOK(ecode14)) {
11945  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
11946  }
11947  arg14 = (PLINT)(val14);
11948  ecode15 = SWIG_AsVal_double(args(12), &val15);
11949  if (!SWIG_IsOK(ecode15)) {
11950  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
11951  }
11952  arg15 = (PLFLT)(val15);
11953  {
11954  if ( _n_dims( args(13) ) > 1 )
11955  {
11956  error( "argument must be a scalar or vector" ); SWIG_fail;
11957  }
11958  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
11959  arg17 = new PLINT[Alen];
11960  temp16 = args(13).matrix_value();
11961  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
11962  }
11963  {
11964  charMatrix temp_matrix;
11965  Cell temp_cell;
11966  char *tmp_cstring;
11967  std::string str;
11968  size_t max_length = 0, non_blank_length;
11969  int i, ifcell;
11970  if ( _n_dims( args(14) ) > 2 )
11971  {
11972  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11973  }
11974  if ( !args(14).is_empty() )
11975  {
11976  if ( _dim( args(14), 0 ) != Alen )
11977  {
11978  error( "first dimension must be same length as previous vector" ); SWIG_fail;
11979  }
11980  arg18 = new char*[Alen];
11981  ifcell = args(14).is_cell();
11982  if ( ifcell )
11983  {
11984  temp_cell = args(14).cell_value();
11985  }
11986  else
11987  {
11988  temp_matrix = args(14).char_matrix_value();
11989  // Allow one extra space for null termination.
11990  max_length = _dim( args(14), 1 ) + 1;
11991  }
11992 
11993  for ( i = 0; i < Alen; i++ )
11994  {
11995  // Must copy string to "permanent" location because the string
11996  // location corresponding to tmp_cstring gets
11997  // overwritten for each iteration of loop.
11998  if ( ifcell )
11999  {
12000  if ( temp_cell.elem( i ).is_string() )
12001  {
12002  str = temp_cell.elem( i ).string_value();
12003  // leave room for null termination.
12004  max_length = str.size() + 1;
12005  tmp_cstring = (char *) str.c_str();
12006  }
12007  else
12008  {
12009  // Use null string if user attempts to pass a cell array
12010  // with a non-string element (likely an empty element
12011  // since that should be allowed by the PLplot interface
12012  // if that element is going to be unused).
12013  // leave room for null termination.
12014  max_length = 1;
12015  tmp_cstring = (char *) "";
12016  }
12017  }
12018  else
12019  {
12020  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12021  }
12022  arg18[i] = new char[max_length];
12023  strncpy( arg18[i], tmp_cstring, max_length - 1 );
12024  arg18[i][max_length - 1] = '\0';
12025  // All the trailing blank crapola should not be needed for
12026  // string cell arrays.
12027  if ( !ifcell )
12028  {
12029  // remove trailing-blank padding that is used by the
12030  // charMatrix class to insure all strings in a given
12031  // charMatrix instance have the same length.
12032  // This transformation also removes legitimate trailing
12033  // blanks but there is nothing we can do about that
12034  // for the charMatrix class.
12035 
12036  // Look for trailing nulls first (just in case, although that
12037  // shouldn't happen if charMatrix implemented as documented)
12038  // before looking for trailing blanks.
12039  non_blank_length = max_length - 2;
12040  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
12041  {
12042  non_blank_length--;
12043  }
12044  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
12045  {
12046  non_blank_length--;
12047  }
12048  arg18[i][non_blank_length + 1] = '\0';
12049  }
12050  }
12051  }
12052  else
12053  {
12054  arg18 = NULL;
12055  }
12056  }
12057  {
12058  charMatrix temp_matrix;
12059  Cell temp_cell;
12060  char *tmp_cstring;
12061  std::string str;
12062  size_t max_length = 0, non_blank_length;
12063  int i, ifcell;
12064  if ( _n_dims( args(15) ) > 2 )
12065  {
12066  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
12067  }
12068  if ( !args(15).is_empty() )
12069  {
12070  Alen = _dim( args(15), 0 );
12071  arg19 = Alen;
12072  arg20 = new char*[Alen];
12073  ifcell = args(15).is_cell();
12074  if ( ifcell )
12075  {
12076  temp_cell = args(15).cell_value();
12077  }
12078  else
12079  {
12080  temp_matrix = args(15).char_matrix_value();
12081  // Allow one extra space for null termination.
12082  max_length = _dim( args(15), 1 ) + 1;
12083  }
12084 
12085  for ( i = 0; i < Alen; i++ )
12086  {
12087  // Must copy string to "permanent" location because the string
12088  // location corresponding to tmp_cstring gets
12089  // overwritten for each iteration of loop.
12090  if ( ifcell )
12091  {
12092  if ( temp_cell.elem( i ).is_string() )
12093  {
12094  str = temp_cell.elem( i ).string_value();
12095  // leave room for null termination.
12096  max_length = str.size() + 1;
12097  tmp_cstring = (char *) str.c_str();
12098  }
12099  else
12100  {
12101  // Use null string if user attempts to pass a cell array
12102  // with a non-string element (likely an empty element
12103  // since that should be allowed by the PLplot interface
12104  // if that element is going to be unused).
12105  // leave room for null termination.
12106  max_length = 1;
12107  tmp_cstring = (char *) "";
12108  }
12109  }
12110  else
12111  {
12112  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12113  }
12114  arg20[i] = new char[max_length];
12115  strncpy( arg20[i], tmp_cstring, max_length - 1 );
12116  arg20[i][max_length - 1] = '\0';
12117  // All the trailing blank crapola should not be needed for
12118  // string cell arrays.
12119  if ( !ifcell )
12120  {
12121  // remove trailing-blank padding that is used by the
12122  // charMatrix class to insure all strings in a given
12123  // charMatrix instance have the same length.
12124  // This transformation also removes legitimate trailing
12125  // blanks but there is nothing we can do about that
12126  // for the charMatrix class.
12127 
12128  // Look for trailing nulls first (just in case, although that
12129  // shouldn't happen if charMatrix implemented as documented)
12130  // before looking for trailing blanks.
12131  non_blank_length = max_length - 2;
12132  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
12133  {
12134  non_blank_length--;
12135  }
12136  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
12137  {
12138  non_blank_length--;
12139  }
12140  arg20[i][non_blank_length + 1] = '\0';
12141  }
12142  }
12143  }
12144  else
12145  {
12146  arg19 = 0;
12147  arg20 = NULL;
12148  }
12149  }
12150  {
12151  if ( _n_dims( args(16) ) > 1 )
12152  {
12153  error( "argument must be a scalar or vector" ); SWIG_fail;
12154  }
12155  if ( _dim( args(16), 0 ) != Alen )
12156  {
12157  error( "argument vectors must be same length" ); SWIG_fail;
12158  }
12159  temp21 = args(16).matrix_value();
12160  arg21 = &temp21( 0, 0 );
12161  }
12162  {
12163  if ( _n_dims( args(17) ) > 1 )
12164  {
12165  error( "argument must be a scalar or vector" ); SWIG_fail;
12166  }
12167  if ( _dim( args(17), 0 ) != Alen )
12168  {
12169  error( "argument vectors must be same length" ); SWIG_fail;
12170  }
12171  temp22 = args(17).matrix_value();
12172  arg22 = new PLINT[Alen];
12173  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
12174  }
12175  {
12176  int i;
12177  if ( _n_dims( args(18) ) > 1 )
12178  {
12179  error( "argument must be a scalar or vector" ); SWIG_fail;
12180  }
12181  if ( _dim( args(18), 0 ) != Alen )
12182  {
12183  error( "argument vectors must be same length" ); SWIG_fail;
12184  }
12185  Xlen = Alen;
12186  temp23 = args(18).matrix_value();
12187  arg23 = new PLINT[Alen];
12188  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
12189  Ylen = -1;
12190  for ( i = 0; i < Xlen; i++ )
12191  if ( arg23[i] > Ylen )
12192  Ylen = arg23[i];
12193  }
12194  {
12195  if ( _n_dims( args(19) ) > 2 )
12196  {
12197  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12198  }
12199  if ( _dim( args(19), 0 ) != Xlen )
12200  {
12201  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12202  }
12203  if ( _dim( args(19), 1 ) != Ylen )
12204  {
12205  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12206  }
12207  temp24 = args(19).matrix_value();
12208  arg24 = &temp24( 0, 0 );
12209  }
12210  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);
12211  _outv = octave_value();
12212  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12213  if (SWIG_IsTmpObj(res1)) {
12214  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
12215  } else {
12216  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12217  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
12218  }
12219  if (SWIG_IsTmpObj(res2)) {
12220  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
12221  } else {
12222  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12223  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
12224  }
12225  {
12226  delete [] arg17;
12227  }
12228  {
12229  int i;
12230  if ( arg18 != NULL )
12231  {
12232  for ( i = 0; i < Alen; i++ )
12233  {
12234  delete[] arg18[i];
12235  }
12236  delete[] arg18;
12237  }
12238  }
12239  {
12240  int i;
12241  if ( arg20 != NULL )
12242  {
12243  for ( i = 0; i < Alen; i++ )
12244  {
12245  delete[] arg20[i];
12246  }
12247  delete[] arg20;
12248  }
12249  }
12250  {
12251 
12252  }
12253  {
12254  delete [] arg22;
12255  }
12256  {
12257  delete [] arg23;
12258  }
12259  {
12260 
12261  }
12262 fail:
12263  return _out;
12264 }
12265 
12266 
12267 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
12268  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12269  int arg2 ;
12270  void *argp1 = 0 ;
12271  int res1 = 0 ;
12272  int val2 ;
12273  int ecode2 = 0 ;
12274  octave_value_list _out;
12275  octave_value_list *_outp=&_out;
12276  octave_value _outv;
12277 
12278  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
12279  SWIG_fail;
12280  }
12281  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12282  if (!SWIG_IsOK(res1)) {
12283  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12284  }
12285  arg1 = (PLGraphicsIn *)(argp1);
12286  ecode2 = SWIG_AsVal_int(args(1), &val2);
12287  if (!SWIG_IsOK(ecode2)) {
12288  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
12289  }
12290  arg2 = (int)(val2);
12291  if (arg1) (arg1)->type = arg2;
12292  _outv = octave_value();
12293  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12294 fail:
12295  return _out;
12296 }
12297 
12298 
12299 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
12300  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12301  void *argp1 = 0 ;
12302  int res1 = 0 ;
12303  octave_value_list _out;
12304  octave_value_list *_outp=&_out;
12305  octave_value _outv;
12306  int result;
12307 
12308  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
12309  SWIG_fail;
12310  }
12311  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12312  if (!SWIG_IsOK(res1)) {
12313  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12314  }
12315  arg1 = (PLGraphicsIn *)(argp1);
12316  result = (int) ((arg1)->type);
12317  _outv = SWIG_From_int((int)(result));
12318  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12319 fail:
12320  return _out;
12321 }
12322 
12323 
12324 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
12325  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12326  unsigned int arg2 ;
12327  void *argp1 = 0 ;
12328  int res1 = 0 ;
12329  unsigned int val2 ;
12330  int ecode2 = 0 ;
12331  octave_value_list _out;
12332  octave_value_list *_outp=&_out;
12333  octave_value _outv;
12334 
12335  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
12336  SWIG_fail;
12337  }
12338  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12339  if (!SWIG_IsOK(res1)) {
12340  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12341  }
12342  arg1 = (PLGraphicsIn *)(argp1);
12343  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12344  if (!SWIG_IsOK(ecode2)) {
12345  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
12346  }
12347  arg2 = (unsigned int)(val2);
12348  if (arg1) (arg1)->state = arg2;
12349  _outv = octave_value();
12350  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12351 fail:
12352  return _out;
12353 }
12354 
12355 
12356 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
12357  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12358  void *argp1 = 0 ;
12359  int res1 = 0 ;
12360  octave_value_list _out;
12361  octave_value_list *_outp=&_out;
12362  octave_value _outv;
12363  unsigned int result;
12364 
12365  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
12366  SWIG_fail;
12367  }
12368  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12369  if (!SWIG_IsOK(res1)) {
12370  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12371  }
12372  arg1 = (PLGraphicsIn *)(argp1);
12373  result = (unsigned int) ((arg1)->state);
12374  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12375  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12376 fail:
12377  return _out;
12378 }
12379 
12380 
12381 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
12382  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12383  unsigned int arg2 ;
12384  void *argp1 = 0 ;
12385  int res1 = 0 ;
12386  unsigned int val2 ;
12387  int ecode2 = 0 ;
12388  octave_value_list _out;
12389  octave_value_list *_outp=&_out;
12390  octave_value _outv;
12391 
12392  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
12393  SWIG_fail;
12394  }
12395  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12396  if (!SWIG_IsOK(res1)) {
12397  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12398  }
12399  arg1 = (PLGraphicsIn *)(argp1);
12400  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12401  if (!SWIG_IsOK(ecode2)) {
12402  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
12403  }
12404  arg2 = (unsigned int)(val2);
12405  if (arg1) (arg1)->keysym = arg2;
12406  _outv = octave_value();
12407  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12408 fail:
12409  return _out;
12410 }
12411 
12412 
12413 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
12414  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12415  void *argp1 = 0 ;
12416  int res1 = 0 ;
12417  octave_value_list _out;
12418  octave_value_list *_outp=&_out;
12419  octave_value _outv;
12420  unsigned int result;
12421 
12422  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
12423  SWIG_fail;
12424  }
12425  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12426  if (!SWIG_IsOK(res1)) {
12427  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12428  }
12429  arg1 = (PLGraphicsIn *)(argp1);
12430  result = (unsigned int) ((arg1)->keysym);
12431  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12432  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12433 fail:
12434  return _out;
12435 }
12436 
12437 
12438 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
12439  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12440  unsigned int arg2 ;
12441  void *argp1 = 0 ;
12442  int res1 = 0 ;
12443  unsigned int val2 ;
12444  int ecode2 = 0 ;
12445  octave_value_list _out;
12446  octave_value_list *_outp=&_out;
12447  octave_value _outv;
12448 
12449  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
12450  SWIG_fail;
12451  }
12452  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12453  if (!SWIG_IsOK(res1)) {
12454  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12455  }
12456  arg1 = (PLGraphicsIn *)(argp1);
12457  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12458  if (!SWIG_IsOK(ecode2)) {
12459  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
12460  }
12461  arg2 = (unsigned int)(val2);
12462  if (arg1) (arg1)->button = arg2;
12463  _outv = octave_value();
12464  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12465 fail:
12466  return _out;
12467 }
12468 
12469 
12470 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
12471  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12472  void *argp1 = 0 ;
12473  int res1 = 0 ;
12474  octave_value_list _out;
12475  octave_value_list *_outp=&_out;
12476  octave_value _outv;
12477  unsigned int result;
12478 
12479  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
12480  SWIG_fail;
12481  }
12482  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12483  if (!SWIG_IsOK(res1)) {
12484  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12485  }
12486  arg1 = (PLGraphicsIn *)(argp1);
12487  result = (unsigned int) ((arg1)->button);
12488  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12489  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12490 fail:
12491  return _out;
12492 }
12493 
12494 
12495 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
12496  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12497  PLINT arg2 ;
12498  void *argp1 = 0 ;
12499  int res1 = 0 ;
12500  int val2 ;
12501  int ecode2 = 0 ;
12502  octave_value_list _out;
12503  octave_value_list *_outp=&_out;
12504  octave_value _outv;
12505 
12506  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
12507  SWIG_fail;
12508  }
12509  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12510  if (!SWIG_IsOK(res1)) {
12511  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12512  }
12513  arg1 = (PLGraphicsIn *)(argp1);
12514  ecode2 = SWIG_AsVal_int(args(1), &val2);
12515  if (!SWIG_IsOK(ecode2)) {
12516  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
12517  }
12518  arg2 = (PLINT)(val2);
12519  if (arg1) (arg1)->subwindow = arg2;
12520  _outv = octave_value();
12521  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12522 fail:
12523  return _out;
12524 }
12525 
12526 
12527 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
12528  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12529  void *argp1 = 0 ;
12530  int res1 = 0 ;
12531  octave_value_list _out;
12532  octave_value_list *_outp=&_out;
12533  octave_value _outv;
12534  PLINT result;
12535 
12536  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
12537  SWIG_fail;
12538  }
12539  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12540  if (!SWIG_IsOK(res1)) {
12541  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12542  }
12543  arg1 = (PLGraphicsIn *)(argp1);
12544  result = (PLINT) ((arg1)->subwindow);
12545  _outv = SWIG_From_int((int)(result));
12546  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12547 fail:
12548  return _out;
12549 }
12550 
12551 
12552 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
12553  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12554  char *arg2 ;
12555  void *argp1 = 0 ;
12556  int res1 = 0 ;
12557  char temp2[16] ;
12558  int res2 ;
12559  octave_value_list _out;
12560  octave_value_list *_outp=&_out;
12561  octave_value _outv;
12562 
12563  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
12564  SWIG_fail;
12565  }
12566  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12567  if (!SWIG_IsOK(res1)) {
12568  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12569  }
12570  arg1 = (PLGraphicsIn *)(argp1);
12571  res2 = SWIG_AsCharArray(args(1), temp2, 16);
12572  if (!SWIG_IsOK(res2)) {
12573  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
12574  }
12575  arg2 = (char *)(temp2);
12576  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
12577  else memset(arg1->string,0,16*sizeof(char));
12578  _outv = octave_value();
12579  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12580 fail:
12581  return _out;
12582 }
12583 
12584 
12585 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
12586  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12587  void *argp1 = 0 ;
12588  int res1 = 0 ;
12589  octave_value_list _out;
12590  octave_value_list *_outp=&_out;
12591  octave_value _outv;
12592  char *result = 0 ;
12593 
12594  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
12595  SWIG_fail;
12596  }
12597  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12598  if (!SWIG_IsOK(res1)) {
12599  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12600  }
12601  arg1 = (PLGraphicsIn *)(argp1);
12602  result = (char *)(char *) ((arg1)->string);
12603  {
12604  size_t size = 16;
12605 
12606  while (size && (result[size - 1] == '\0')) --size;
12607 
12608  _outv = SWIG_FromCharPtrAndSize(result, size);
12609  }
12610  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12611 fail:
12612  return _out;
12613 }
12614 
12615 
12616 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
12617  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12618  int arg2 ;
12619  void *argp1 = 0 ;
12620  int res1 = 0 ;
12621  int val2 ;
12622  int ecode2 = 0 ;
12623  octave_value_list _out;
12624  octave_value_list *_outp=&_out;
12625  octave_value _outv;
12626 
12627  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
12628  SWIG_fail;
12629  }
12630  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12631  if (!SWIG_IsOK(res1)) {
12632  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12633  }
12634  arg1 = (PLGraphicsIn *)(argp1);
12635  ecode2 = SWIG_AsVal_int(args(1), &val2);
12636  if (!SWIG_IsOK(ecode2)) {
12637  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
12638  }
12639  arg2 = (int)(val2);
12640  if (arg1) (arg1)->pX = arg2;
12641  _outv = octave_value();
12642  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12643 fail:
12644  return _out;
12645 }
12646 
12647 
12648 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
12649  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12650  void *argp1 = 0 ;
12651  int res1 = 0 ;
12652  octave_value_list _out;
12653  octave_value_list *_outp=&_out;
12654  octave_value _outv;
12655  int result;
12656 
12657  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
12658  SWIG_fail;
12659  }
12660  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12661  if (!SWIG_IsOK(res1)) {
12662  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12663  }
12664  arg1 = (PLGraphicsIn *)(argp1);
12665  result = (int) ((arg1)->pX);
12666  _outv = SWIG_From_int((int)(result));
12667  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12668 fail:
12669  return _out;
12670 }
12671 
12672 
12673 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
12674  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12675  int arg2 ;
12676  void *argp1 = 0 ;
12677  int res1 = 0 ;
12678  int val2 ;
12679  int ecode2 = 0 ;
12680  octave_value_list _out;
12681  octave_value_list *_outp=&_out;
12682  octave_value _outv;
12683 
12684  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
12685  SWIG_fail;
12686  }
12687  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12688  if (!SWIG_IsOK(res1)) {
12689  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12690  }
12691  arg1 = (PLGraphicsIn *)(argp1);
12692  ecode2 = SWIG_AsVal_int(args(1), &val2);
12693  if (!SWIG_IsOK(ecode2)) {
12694  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
12695  }
12696  arg2 = (int)(val2);
12697  if (arg1) (arg1)->pY = arg2;
12698  _outv = octave_value();
12699  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12700 fail:
12701  return _out;
12702 }
12703 
12704 
12705 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
12706  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12707  void *argp1 = 0 ;
12708  int res1 = 0 ;
12709  octave_value_list _out;
12710  octave_value_list *_outp=&_out;
12711  octave_value _outv;
12712  int result;
12713 
12714  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
12715  SWIG_fail;
12716  }
12717  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12718  if (!SWIG_IsOK(res1)) {
12719  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12720  }
12721  arg1 = (PLGraphicsIn *)(argp1);
12722  result = (int) ((arg1)->pY);
12723  _outv = SWIG_From_int((int)(result));
12724  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12725 fail:
12726  return _out;
12727 }
12728 
12729 
12730 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
12731  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12732  PLFLT arg2 ;
12733  void *argp1 = 0 ;
12734  int res1 = 0 ;
12735  double val2 ;
12736  int ecode2 = 0 ;
12737  octave_value_list _out;
12738  octave_value_list *_outp=&_out;
12739  octave_value _outv;
12740 
12741  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
12742  SWIG_fail;
12743  }
12744  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12745  if (!SWIG_IsOK(res1)) {
12746  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12747  }
12748  arg1 = (PLGraphicsIn *)(argp1);
12749  ecode2 = SWIG_AsVal_double(args(1), &val2);
12750  if (!SWIG_IsOK(ecode2)) {
12751  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
12752  }
12753  arg2 = (PLFLT)(val2);
12754  if (arg1) (arg1)->dX = arg2;
12755  _outv = octave_value();
12756  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12757 fail:
12758  return _out;
12759 }
12760 
12761 
12762 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
12763  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12764  void *argp1 = 0 ;
12765  int res1 = 0 ;
12766  octave_value_list _out;
12767  octave_value_list *_outp=&_out;
12768  octave_value _outv;
12769  PLFLT result;
12770 
12771  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
12772  SWIG_fail;
12773  }
12774  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12775  if (!SWIG_IsOK(res1)) {
12776  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12777  }
12778  arg1 = (PLGraphicsIn *)(argp1);
12779  result = (PLFLT) ((arg1)->dX);
12780  _outv = SWIG_From_double((double)(result));
12781  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12782 fail:
12783  return _out;
12784 }
12785 
12786 
12787 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
12788  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12789  PLFLT arg2 ;
12790  void *argp1 = 0 ;
12791  int res1 = 0 ;
12792  double val2 ;
12793  int ecode2 = 0 ;
12794  octave_value_list _out;
12795  octave_value_list *_outp=&_out;
12796  octave_value _outv;
12797 
12798  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
12799  SWIG_fail;
12800  }
12801  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12802  if (!SWIG_IsOK(res1)) {
12803  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12804  }
12805  arg1 = (PLGraphicsIn *)(argp1);
12806  ecode2 = SWIG_AsVal_double(args(1), &val2);
12807  if (!SWIG_IsOK(ecode2)) {
12808  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
12809  }
12810  arg2 = (PLFLT)(val2);
12811  if (arg1) (arg1)->dY = arg2;
12812  _outv = octave_value();
12813  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12814 fail:
12815  return _out;
12816 }
12817 
12818 
12819 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
12820  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12821  void *argp1 = 0 ;
12822  int res1 = 0 ;
12823  octave_value_list _out;
12824  octave_value_list *_outp=&_out;
12825  octave_value _outv;
12826  PLFLT result;
12827 
12828  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
12829  SWIG_fail;
12830  }
12831  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12832  if (!SWIG_IsOK(res1)) {
12833  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12834  }
12835  arg1 = (PLGraphicsIn *)(argp1);
12836  result = (PLFLT) ((arg1)->dY);
12837  _outv = SWIG_From_double((double)(result));
12838  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12839 fail:
12840  return _out;
12841 }
12842 
12843 
12844 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
12845  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12846  PLFLT arg2 ;
12847  void *argp1 = 0 ;
12848  int res1 = 0 ;
12849  double val2 ;
12850  int ecode2 = 0 ;
12851  octave_value_list _out;
12852  octave_value_list *_outp=&_out;
12853  octave_value _outv;
12854 
12855  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
12856  SWIG_fail;
12857  }
12858  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12859  if (!SWIG_IsOK(res1)) {
12860  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12861  }
12862  arg1 = (PLGraphicsIn *)(argp1);
12863  ecode2 = SWIG_AsVal_double(args(1), &val2);
12864  if (!SWIG_IsOK(ecode2)) {
12865  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
12866  }
12867  arg2 = (PLFLT)(val2);
12868  if (arg1) (arg1)->wX = arg2;
12869  _outv = octave_value();
12870  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12871 fail:
12872  return _out;
12873 }
12874 
12875 
12876 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
12877  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12878  void *argp1 = 0 ;
12879  int res1 = 0 ;
12880  octave_value_list _out;
12881  octave_value_list *_outp=&_out;
12882  octave_value _outv;
12883  PLFLT result;
12884 
12885  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
12886  SWIG_fail;
12887  }
12888  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12889  if (!SWIG_IsOK(res1)) {
12890  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12891  }
12892  arg1 = (PLGraphicsIn *)(argp1);
12893  result = (PLFLT) ((arg1)->wX);
12894  _outv = SWIG_From_double((double)(result));
12895  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12896 fail:
12897  return _out;
12898 }
12899 
12900 
12901 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
12902  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12903  PLFLT arg2 ;
12904  void *argp1 = 0 ;
12905  int res1 = 0 ;
12906  double val2 ;
12907  int ecode2 = 0 ;
12908  octave_value_list _out;
12909  octave_value_list *_outp=&_out;
12910  octave_value _outv;
12911 
12912  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
12913  SWIG_fail;
12914  }
12915  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12916  if (!SWIG_IsOK(res1)) {
12917  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12918  }
12919  arg1 = (PLGraphicsIn *)(argp1);
12920  ecode2 = SWIG_AsVal_double(args(1), &val2);
12921  if (!SWIG_IsOK(ecode2)) {
12922  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
12923  }
12924  arg2 = (PLFLT)(val2);
12925  if (arg1) (arg1)->wY = arg2;
12926  _outv = octave_value();
12927  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12928 fail:
12929  return _out;
12930 }
12931 
12932 
12933 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
12934  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12935  void *argp1 = 0 ;
12936  int res1 = 0 ;
12937  octave_value_list _out;
12938  octave_value_list *_outp=&_out;
12939  octave_value _outv;
12940  PLFLT result;
12941 
12942  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
12943  SWIG_fail;
12944  }
12945  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12946  if (!SWIG_IsOK(res1)) {
12947  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12948  }
12949  arg1 = (PLGraphicsIn *)(argp1);
12950  result = (PLFLT) ((arg1)->wY);
12951  _outv = SWIG_From_double((double)(result));
12952  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12953 fail:
12954  return _out;
12955 }
12956 
12957 
12958 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
12959  octave_value_list _out;
12960  octave_value_list *_outp=&_out;
12961  octave_value _outv;
12962  PLGraphicsIn *result = 0 ;
12963 
12964  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
12965  SWIG_fail;
12966  }
12967  result = (PLGraphicsIn *)new PLGraphicsIn();
12969  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12970 fail:
12971  return _out;
12972 }
12973 
12974 
12975 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
12976  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12977  void *argp1 = 0 ;
12978  int res1 = 0 ;
12979  octave_value_list _out;
12980  octave_value_list *_outp=&_out;
12981  octave_value _outv;
12982 
12983  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
12984  SWIG_fail;
12985  }
12986  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
12987  if (!SWIG_IsOK(res1)) {
12988  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12989  }
12990  arg1 = (PLGraphicsIn *)(argp1);
12991  delete arg1;
12992  _outv = octave_value();
12993  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12994 fail:
12995  return _out;
12996 }
12997 
12998 
13012 {0,0,0,0}
13013 };
13014 static const char *swig_PLGraphicsIn_base_names[] = {0};
13017 
13018 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
13019  PLINT arg1 ;
13020  PLINT arg2 ;
13021  int val1 ;
13022  int ecode1 = 0 ;
13023  int val2 ;
13024  int ecode2 = 0 ;
13025  octave_value_list _out;
13026  octave_value_list *_outp=&_out;
13027  octave_value _outv;
13028 
13029  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
13030  SWIG_fail;
13031  }
13032  ecode1 = SWIG_AsVal_int(args(0), &val1);
13033  if (!SWIG_IsOK(ecode1)) {
13034  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
13035  }
13036  arg1 = (PLINT)(val1);
13037  ecode2 = SWIG_AsVal_int(args(1), &val2);
13038  if (!SWIG_IsOK(ecode2)) {
13039  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
13040  }
13041  arg2 = (PLINT)(val2);
13042  pl_setcontlabelformat(arg1,arg2);
13043  _outv = octave_value();
13044  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13045 fail:
13046  return _out;
13047 }
13048 
13049 
13050 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
13051  PLFLT arg1 ;
13052  PLFLT arg2 ;
13053  PLFLT arg3 ;
13054  PLINT arg4 ;
13055  double val1 ;
13056  int ecode1 = 0 ;
13057  double val2 ;
13058  int ecode2 = 0 ;
13059  double val3 ;
13060  int ecode3 = 0 ;
13061  int val4 ;
13062  int ecode4 = 0 ;
13063  octave_value_list _out;
13064  octave_value_list *_outp=&_out;
13065  octave_value _outv;
13066 
13067  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
13068  SWIG_fail;
13069  }
13070  ecode1 = SWIG_AsVal_double(args(0), &val1);
13071  if (!SWIG_IsOK(ecode1)) {
13072  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
13073  }
13074  arg1 = (PLFLT)(val1);
13075  ecode2 = SWIG_AsVal_double(args(1), &val2);
13076  if (!SWIG_IsOK(ecode2)) {
13077  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
13078  }
13079  arg2 = (PLFLT)(val2);
13080  ecode3 = SWIG_AsVal_double(args(2), &val3);
13081  if (!SWIG_IsOK(ecode3)) {
13082  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
13083  }
13084  arg3 = (PLFLT)(val3);
13085  ecode4 = SWIG_AsVal_int(args(3), &val4);
13086  if (!SWIG_IsOK(ecode4)) {
13087  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
13088  }
13089  arg4 = (PLINT)(val4);
13090  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
13091  _outv = octave_value();
13092  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13093 fail:
13094  return _out;
13095 }
13096 
13097 
13098 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
13099  PLINT arg1 ;
13100  int val1 ;
13101  int ecode1 = 0 ;
13102  octave_value_list _out;
13103  octave_value_list *_outp=&_out;
13104  octave_value _outv;
13105 
13106  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
13107  SWIG_fail;
13108  }
13109  ecode1 = SWIG_AsVal_int(args(0), &val1);
13110  if (!SWIG_IsOK(ecode1)) {
13111  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
13112  }
13113  arg1 = (PLINT)(val1);
13114  pladv(arg1);
13115  _outv = octave_value();
13116  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13117 fail:
13118  return _out;
13119 }
13120 
13121 
13122 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
13123  PLFLT arg1 ;
13124  PLFLT arg2 ;
13125  PLFLT arg3 ;
13126  PLFLT arg4 ;
13127  PLFLT arg5 ;
13128  PLFLT arg6 ;
13129  PLFLT arg7 ;
13130  PLBOOL arg8 ;
13131  double val1 ;
13132  int ecode1 = 0 ;
13133  double val2 ;
13134  int ecode2 = 0 ;
13135  double val3 ;
13136  int ecode3 = 0 ;
13137  double val4 ;
13138  int ecode4 = 0 ;
13139  double val5 ;
13140  int ecode5 = 0 ;
13141  double val6 ;
13142  int ecode6 = 0 ;
13143  double val7 ;
13144  int ecode7 = 0 ;
13145  int val8 ;
13146  int ecode8 = 0 ;
13147  octave_value_list _out;
13148  octave_value_list *_outp=&_out;
13149  octave_value _outv;
13150 
13151  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
13152  SWIG_fail;
13153  }
13154  ecode1 = SWIG_AsVal_double(args(0), &val1);
13155  if (!SWIG_IsOK(ecode1)) {
13156  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
13157  }
13158  arg1 = (PLFLT)(val1);
13159  ecode2 = SWIG_AsVal_double(args(1), &val2);
13160  if (!SWIG_IsOK(ecode2)) {
13161  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
13162  }
13163  arg2 = (PLFLT)(val2);
13164  ecode3 = SWIG_AsVal_double(args(2), &val3);
13165  if (!SWIG_IsOK(ecode3)) {
13166  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
13167  }
13168  arg3 = (PLFLT)(val3);
13169  ecode4 = SWIG_AsVal_double(args(3), &val4);
13170  if (!SWIG_IsOK(ecode4)) {
13171  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
13172  }
13173  arg4 = (PLFLT)(val4);
13174  ecode5 = SWIG_AsVal_double(args(4), &val5);
13175  if (!SWIG_IsOK(ecode5)) {
13176  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
13177  }
13178  arg5 = (PLFLT)(val5);
13179  ecode6 = SWIG_AsVal_double(args(5), &val6);
13180  if (!SWIG_IsOK(ecode6)) {
13181  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
13182  }
13183  arg6 = (PLFLT)(val6);
13184  ecode7 = SWIG_AsVal_double(args(6), &val7);
13185  if (!SWIG_IsOK(ecode7)) {
13186  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
13187  }
13188  arg7 = (PLFLT)(val7);
13189  ecode8 = SWIG_AsVal_int(args(7), &val8);
13190  if (!SWIG_IsOK(ecode8)) {
13191  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
13192  }
13193  arg8 = (PLBOOL)(val8);
13194  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
13195  _outv = octave_value();
13196  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13197 fail:
13198  return _out;
13199 }
13200 
13201 
13202 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
13203  PLFLT arg1 ;
13204  PLFLT arg2 ;
13205  char *arg3 = (char *) 0 ;
13206  PLFLT arg4 ;
13207  PLINT arg5 ;
13208  char *arg6 = (char *) 0 ;
13209  PLFLT arg7 ;
13210  PLINT arg8 ;
13211  double val1 ;
13212  int ecode1 = 0 ;
13213  double val2 ;
13214  int ecode2 = 0 ;
13215  int res3 ;
13216  char *buf3 = 0 ;
13217  int alloc3 = 0 ;
13218  double val4 ;
13219  int ecode4 = 0 ;
13220  int val5 ;
13221  int ecode5 = 0 ;
13222  int res6 ;
13223  char *buf6 = 0 ;
13224  int alloc6 = 0 ;
13225  double val7 ;
13226  int ecode7 = 0 ;
13227  int val8 ;
13228  int ecode8 = 0 ;
13229  octave_value_list _out;
13230  octave_value_list *_outp=&_out;
13231  octave_value _outv;
13232 
13233  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
13234  SWIG_fail;
13235  }
13236  ecode1 = SWIG_AsVal_double(args(0), &val1);
13237  if (!SWIG_IsOK(ecode1)) {
13238  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
13239  }
13240  arg1 = (PLFLT)(val1);
13241  ecode2 = SWIG_AsVal_double(args(1), &val2);
13242  if (!SWIG_IsOK(ecode2)) {
13243  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
13244  }
13245  arg2 = (PLFLT)(val2);
13246  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
13247  if (!SWIG_IsOK(res3)) {
13248  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
13249  }
13250  arg3 = (char *)(buf3);
13251  ecode4 = SWIG_AsVal_double(args(3), &val4);
13252  if (!SWIG_IsOK(ecode4)) {
13253  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
13254  }
13255  arg4 = (PLFLT)(val4);
13256  ecode5 = SWIG_AsVal_int(args(4), &val5);
13257  if (!SWIG_IsOK(ecode5)) {
13258  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
13259  }
13260  arg5 = (PLINT)(val5);
13261  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13262  if (!SWIG_IsOK(res6)) {
13263  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
13264  }
13265  arg6 = (char *)(buf6);
13266  ecode7 = SWIG_AsVal_double(args(6), &val7);
13267  if (!SWIG_IsOK(ecode7)) {
13268  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
13269  }
13270  arg7 = (PLFLT)(val7);
13271  ecode8 = SWIG_AsVal_int(args(7), &val8);
13272  if (!SWIG_IsOK(ecode8)) {
13273  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
13274  }
13275  arg8 = (PLINT)(val8);
13276  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
13277  _outv = octave_value();
13278  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13279  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
13280  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13281 fail:
13282  return _out;
13283 }
13284 
13285 
13286 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
13287  PLINT arg1 ;
13288  PLFLT *arg2 = (PLFLT *) 0 ;
13289  PLFLT *arg3 = (PLFLT *) 0 ;
13290  PLINT arg4 ;
13291  Matrix temp1 ;
13292  Matrix temp3 ;
13293  int val4 ;
13294  int ecode4 = 0 ;
13295  octave_value_list _out;
13296  octave_value_list *_outp=&_out;
13297  octave_value _outv;
13298 
13299  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
13300  SWIG_fail;
13301  }
13302  {
13303  if ( _n_dims( args(0) ) > 1 )
13304  {
13305  error( "argument must be a scalar or vector" ); SWIG_fail;
13306  }
13307  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
13308  temp1 = args(0).matrix_value();
13309  arg2 = &temp1( 0, 0 );
13310  }
13311  {
13312  if ( _n_dims( args(1) ) > 1 )
13313  {
13314  error( "argument must be a scalar or vector" ); SWIG_fail;
13315  }
13316  if ( _dim( args(1), 0 ) != Alen )
13317  {
13318  error( "argument vectors must be same length" ); SWIG_fail;
13319  }
13320  temp3 = args(1).matrix_value();
13321  arg3 = &temp3( 0, 0 );
13322  }
13323  ecode4 = SWIG_AsVal_int(args(2), &val4);
13324  if (!SWIG_IsOK(ecode4)) {
13325  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
13326  }
13327  arg4 = (PLINT)(val4);
13328  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
13329  _outv = octave_value();
13330  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13331  {
13332 
13333  }
13334  {
13335 
13336  }
13337 fail:
13338  return _out;
13339 }
13340 
13341 
13342 SWIG_DEFUN( plbtime, _wrap_plbtime, std::string() ) {
13343  PLINT *arg1 = (PLINT *) 0 ;
13344  PLINT *arg2 = (PLINT *) 0 ;
13345  PLINT *arg3 = (PLINT *) 0 ;
13346  PLINT *arg4 = (PLINT *) 0 ;
13347  PLINT *arg5 = (PLINT *) 0 ;
13348  PLFLT *arg6 = (PLFLT *) 0 ;
13349  PLFLT arg7 ;
13350  PLINT temp1 ;
13351  int res1 = SWIG_TMPOBJ ;
13352  PLINT temp2 ;
13353  int res2 = SWIG_TMPOBJ ;
13354  PLINT temp3 ;
13355  int res3 = SWIG_TMPOBJ ;
13356  PLINT temp4 ;
13357  int res4 = SWIG_TMPOBJ ;
13358  PLINT temp5 ;
13359  int res5 = SWIG_TMPOBJ ;
13360  PLFLT temp6 ;
13361  int res6 = SWIG_TMPOBJ ;
13362  double val7 ;
13363  int ecode7 = 0 ;
13364  octave_value_list _out;
13365  octave_value_list *_outp=&_out;
13366  octave_value _outv;
13367 
13368  arg1 = &temp1;
13369  arg2 = &temp2;
13370  arg3 = &temp3;
13371  arg4 = &temp4;
13372  arg5 = &temp5;
13373  arg6 = &temp6;
13374  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
13375  SWIG_fail;
13376  }
13377  ecode7 = SWIG_AsVal_double(args(0), &val7);
13378  if (!SWIG_IsOK(ecode7)) {
13379  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
13380  }
13381  arg7 = (PLFLT)(val7);
13382  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13383  _outv = octave_value();
13384  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13385  if (SWIG_IsTmpObj(res1)) {
13386  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
13387  } else {
13388  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13389  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13390  }
13391  if (SWIG_IsTmpObj(res2)) {
13392  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
13393  } else {
13394  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13395  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13396  }
13397  if (SWIG_IsTmpObj(res3)) {
13398  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
13399  } else {
13400  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13401  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13402  }
13403  if (SWIG_IsTmpObj(res4)) {
13404  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
13405  } else {
13406  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13407  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
13408  }
13409  if (SWIG_IsTmpObj(res5)) {
13410  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
13411  } else {
13412  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13413  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
13414  }
13415  if (SWIG_IsTmpObj(res6)) {
13416  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
13417  } else {
13418  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13419  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
13420  }
13421 fail:
13422  return _out;
13423 }
13424 
13425 
13426 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
13427  octave_value_list _out;
13428  octave_value_list *_outp=&_out;
13429  octave_value _outv;
13430 
13431  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
13432  SWIG_fail;
13433  }
13434  plbop();
13435  _outv = octave_value();
13436  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13437 fail:
13438  return _out;
13439 }
13440 
13441 
13442 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
13443  char *arg1 = (char *) 0 ;
13444  PLFLT arg2 ;
13445  PLINT arg3 ;
13446  char *arg4 = (char *) 0 ;
13447  PLFLT arg5 ;
13448  PLINT arg6 ;
13449  int res1 ;
13450  char *buf1 = 0 ;
13451  int alloc1 = 0 ;
13452  double val2 ;
13453  int ecode2 = 0 ;
13454  int val3 ;
13455  int ecode3 = 0 ;
13456  int res4 ;
13457  char *buf4 = 0 ;
13458  int alloc4 = 0 ;
13459  double val5 ;
13460  int ecode5 = 0 ;
13461  int val6 ;
13462  int ecode6 = 0 ;
13463  octave_value_list _out;
13464  octave_value_list *_outp=&_out;
13465  octave_value _outv;
13466 
13467  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
13468  SWIG_fail;
13469  }
13470  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13471  if (!SWIG_IsOK(res1)) {
13472  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
13473  }
13474  arg1 = (char *)(buf1);
13475  ecode2 = SWIG_AsVal_double(args(1), &val2);
13476  if (!SWIG_IsOK(ecode2)) {
13477  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
13478  }
13479  arg2 = (PLFLT)(val2);
13480  ecode3 = SWIG_AsVal_int(args(2), &val3);
13481  if (!SWIG_IsOK(ecode3)) {
13482  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
13483  }
13484  arg3 = (PLINT)(val3);
13485  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
13486  if (!SWIG_IsOK(res4)) {
13487  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
13488  }
13489  arg4 = (char *)(buf4);
13490  ecode5 = SWIG_AsVal_double(args(4), &val5);
13491  if (!SWIG_IsOK(ecode5)) {
13492  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
13493  }
13494  arg5 = (PLFLT)(val5);
13495  ecode6 = SWIG_AsVal_int(args(5), &val6);
13496  if (!SWIG_IsOK(ecode6)) {
13497  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
13498  }
13499  arg6 = (PLINT)(val6);
13500  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
13501  _outv = octave_value();
13502  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13503  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13504  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13505 fail:
13506  return _out;
13507 }
13508 
13509 
13510 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
13511  char *arg1 = (char *) 0 ;
13512  char *arg2 = (char *) 0 ;
13513  PLFLT arg3 ;
13514  PLINT arg4 ;
13515  char *arg5 = (char *) 0 ;
13516  char *arg6 = (char *) 0 ;
13517  PLFLT arg7 ;
13518  PLINT arg8 ;
13519  char *arg9 = (char *) 0 ;
13520  char *arg10 = (char *) 0 ;
13521  PLFLT arg11 ;
13522  PLINT arg12 ;
13523  int res1 ;
13524  char *buf1 = 0 ;
13525  int alloc1 = 0 ;
13526  int res2 ;
13527  char *buf2 = 0 ;
13528  int alloc2 = 0 ;
13529  double val3 ;
13530  int ecode3 = 0 ;
13531  int val4 ;
13532  int ecode4 = 0 ;
13533  int res5 ;
13534  char *buf5 = 0 ;
13535  int alloc5 = 0 ;
13536  int res6 ;
13537  char *buf6 = 0 ;
13538  int alloc6 = 0 ;
13539  double val7 ;
13540  int ecode7 = 0 ;
13541  int val8 ;
13542  int ecode8 = 0 ;
13543  int res9 ;
13544  char *buf9 = 0 ;
13545  int alloc9 = 0 ;
13546  int res10 ;
13547  char *buf10 = 0 ;
13548  int alloc10 = 0 ;
13549  double val11 ;
13550  int ecode11 = 0 ;
13551  int val12 ;
13552  int ecode12 = 0 ;
13553  octave_value_list _out;
13554  octave_value_list *_outp=&_out;
13555  octave_value _outv;
13556 
13557  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
13558  SWIG_fail;
13559  }
13560  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13561  if (!SWIG_IsOK(res1)) {
13562  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
13563  }
13564  arg1 = (char *)(buf1);
13565  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
13566  if (!SWIG_IsOK(res2)) {
13567  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
13568  }
13569  arg2 = (char *)(buf2);
13570  ecode3 = SWIG_AsVal_double(args(2), &val3);
13571  if (!SWIG_IsOK(ecode3)) {
13572  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
13573  }
13574  arg3 = (PLFLT)(val3);
13575  ecode4 = SWIG_AsVal_int(args(3), &val4);
13576  if (!SWIG_IsOK(ecode4)) {
13577  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
13578  }
13579  arg4 = (PLINT)(val4);
13580  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
13581  if (!SWIG_IsOK(res5)) {
13582  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
13583  }
13584  arg5 = (char *)(buf5);
13585  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13586  if (!SWIG_IsOK(res6)) {
13587  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
13588  }
13589  arg6 = (char *)(buf6);
13590  ecode7 = SWIG_AsVal_double(args(6), &val7);
13591  if (!SWIG_IsOK(ecode7)) {
13592  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
13593  }
13594  arg7 = (PLFLT)(val7);
13595  ecode8 = SWIG_AsVal_int(args(7), &val8);
13596  if (!SWIG_IsOK(ecode8)) {
13597  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
13598  }
13599  arg8 = (PLINT)(val8);
13600  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
13601  if (!SWIG_IsOK(res9)) {
13602  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
13603  }
13604  arg9 = (char *)(buf9);
13605  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
13606  if (!SWIG_IsOK(res10)) {
13607  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
13608  }
13609  arg10 = (char *)(buf10);
13610  ecode11 = SWIG_AsVal_double(args(10), &val11);
13611  if (!SWIG_IsOK(ecode11)) {
13612  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
13613  }
13614  arg11 = (PLFLT)(val11);
13615  ecode12 = SWIG_AsVal_int(args(11), &val12);
13616  if (!SWIG_IsOK(ecode12)) {
13617  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
13618  }
13619  arg12 = (PLINT)(val12);
13620  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);
13621  _outv = octave_value();
13622  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13623  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13624  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13625  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13626  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13627  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
13628  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
13629 fail:
13630  return _out;
13631 }
13632 
13633 
13634 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
13635  PLFLT arg1 ;
13636  PLFLT arg2 ;
13637  PLFLT *arg3 = (PLFLT *) 0 ;
13638  PLFLT *arg4 = (PLFLT *) 0 ;
13639  PLINT *arg5 = (PLINT *) 0 ;
13640  double val1 ;
13641  int ecode1 = 0 ;
13642  double val2 ;
13643  int ecode2 = 0 ;
13644  PLFLT temp3 ;
13645  int res3 = SWIG_TMPOBJ ;
13646  PLFLT temp4 ;
13647  int res4 = SWIG_TMPOBJ ;
13648  PLINT temp5 ;
13649  int res5 = SWIG_TMPOBJ ;
13650  octave_value_list _out;
13651  octave_value_list *_outp=&_out;
13652  octave_value _outv;
13653 
13654  arg3 = &temp3;
13655  arg4 = &temp4;
13656  arg5 = &temp5;
13657  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
13658  SWIG_fail;
13659  }
13660  ecode1 = SWIG_AsVal_double(args(0), &val1);
13661  if (!SWIG_IsOK(ecode1)) {
13662  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
13663  }
13664  arg1 = (PLFLT)(val1);
13665  ecode2 = SWIG_AsVal_double(args(1), &val2);
13666  if (!SWIG_IsOK(ecode2)) {
13667  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
13668  }
13669  arg2 = (PLFLT)(val2);
13670  plcalc_world(arg1,arg2,arg3,arg4,arg5);
13671  _outv = octave_value();
13672  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13673  if (SWIG_IsTmpObj(res3)) {
13674  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
13675  } else {
13676  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13677  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
13678  }
13679  if (SWIG_IsTmpObj(res4)) {
13680  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
13681  } else {
13682  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13683  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
13684  }
13685  if (SWIG_IsTmpObj(res5)) {
13686  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
13687  } else {
13688  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13689  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
13690  }
13691 fail:
13692  return _out;
13693 }
13694 
13695 
13696 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
13697  octave_value_list _out;
13698  octave_value_list *_outp=&_out;
13699  octave_value _outv;
13700 
13701  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
13702  SWIG_fail;
13703  }
13704  plclear();
13705  _outv = octave_value();
13706  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13707 fail:
13708  return _out;
13709 }
13710 
13711 
13712 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
13713  PLINT arg1 ;
13714  int val1 ;
13715  int ecode1 = 0 ;
13716  octave_value_list _out;
13717  octave_value_list *_outp=&_out;
13718  octave_value _outv;
13719 
13720  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
13721  SWIG_fail;
13722  }
13723  ecode1 = SWIG_AsVal_int(args(0), &val1);
13724  if (!SWIG_IsOK(ecode1)) {
13725  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
13726  }
13727  arg1 = (PLINT)(val1);
13728  plcol0(arg1);
13729  _outv = octave_value();
13730  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13731 fail:
13732  return _out;
13733 }
13734 
13735 
13736 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
13737  PLFLT arg1 ;
13738  double val1 ;
13739  int ecode1 = 0 ;
13740  octave_value_list _out;
13741  octave_value_list *_outp=&_out;
13742  octave_value _outv;
13743 
13744  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
13745  SWIG_fail;
13746  }
13747  ecode1 = SWIG_AsVal_double(args(0), &val1);
13748  if (!SWIG_IsOK(ecode1)) {
13749  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
13750  }
13751  arg1 = (PLFLT)(val1);
13752  plcol1(arg1);
13753  _outv = octave_value();
13754  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13755 fail:
13756  return _out;
13757 }
13758 
13759 
13761  PLFLT arg1 ;
13762  PLFLT arg2 ;
13763  PLFLT arg3 ;
13764  PLINT arg4 ;
13765  PLBOOL arg5 ;
13766  PLINT arg6 ;
13767  PLINT arg7 ;
13768  PLINT arg8 ;
13769  PLINT arg9 ;
13770  PLINT arg10 ;
13771  PLFLT arg11 ;
13772  double val1 ;
13773  int ecode1 = 0 ;
13774  double val2 ;
13775  int ecode2 = 0 ;
13776  double val3 ;
13777  int ecode3 = 0 ;
13778  int val4 ;
13779  int ecode4 = 0 ;
13780  int val5 ;
13781  int ecode5 = 0 ;
13782  int val6 ;
13783  int ecode6 = 0 ;
13784  int val7 ;
13785  int ecode7 = 0 ;
13786  int val8 ;
13787  int ecode8 = 0 ;
13788  int val9 ;
13789  int ecode9 = 0 ;
13790  int val10 ;
13791  int ecode10 = 0 ;
13792  double val11 ;
13793  int ecode11 = 0 ;
13794  octave_value_list _out;
13795  octave_value_list *_outp=&_out;
13796  octave_value _outv;
13797 
13798  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
13799  SWIG_fail;
13800  }
13801  ecode1 = SWIG_AsVal_double(args(0), &val1);
13802  if (!SWIG_IsOK(ecode1)) {
13803  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
13804  }
13805  arg1 = (PLFLT)(val1);
13806  ecode2 = SWIG_AsVal_double(args(1), &val2);
13807  if (!SWIG_IsOK(ecode2)) {
13808  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
13809  }
13810  arg2 = (PLFLT)(val2);
13811  ecode3 = SWIG_AsVal_double(args(2), &val3);
13812  if (!SWIG_IsOK(ecode3)) {
13813  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
13814  }
13815  arg3 = (PLFLT)(val3);
13816  ecode4 = SWIG_AsVal_int(args(3), &val4);
13817  if (!SWIG_IsOK(ecode4)) {
13818  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
13819  }
13820  arg4 = (PLINT)(val4);
13821  ecode5 = SWIG_AsVal_int(args(4), &val5);
13822  if (!SWIG_IsOK(ecode5)) {
13823  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
13824  }
13825  arg5 = (PLBOOL)(val5);
13826  ecode6 = SWIG_AsVal_int(args(5), &val6);
13827  if (!SWIG_IsOK(ecode6)) {
13828  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
13829  }
13830  arg6 = (PLINT)(val6);
13831  ecode7 = SWIG_AsVal_int(args(6), &val7);
13832  if (!SWIG_IsOK(ecode7)) {
13833  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
13834  }
13835  arg7 = (PLINT)(val7);
13836  ecode8 = SWIG_AsVal_int(args(7), &val8);
13837  if (!SWIG_IsOK(ecode8)) {
13838  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
13839  }
13840  arg8 = (PLINT)(val8);
13841  ecode9 = SWIG_AsVal_int(args(8), &val9);
13842  if (!SWIG_IsOK(ecode9)) {
13843  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
13844  }
13845  arg9 = (PLINT)(val9);
13846  ecode10 = SWIG_AsVal_int(args(9), &val10);
13847  if (!SWIG_IsOK(ecode10)) {
13848  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
13849  }
13850  arg10 = (PLINT)(val10);
13851  ecode11 = SWIG_AsVal_double(args(10), &val11);
13852  if (!SWIG_IsOK(ecode11)) {
13853  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
13854  }
13855  arg11 = (PLFLT)(val11);
13856  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13857  _outv = octave_value();
13858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13859 fail:
13860  return _out;
13861 }
13862 
13863 
13864 SWIG_DEFUN( plctime, _wrap_plctime, std::string() ) {
13865  PLINT arg1 ;
13866  PLINT arg2 ;
13867  PLINT arg3 ;
13868  PLINT arg4 ;
13869  PLINT arg5 ;
13870  PLFLT arg6 ;
13871  PLFLT *arg7 = (PLFLT *) 0 ;
13872  int val1 ;
13873  int ecode1 = 0 ;
13874  int val2 ;
13875  int ecode2 = 0 ;
13876  int val3 ;
13877  int ecode3 = 0 ;
13878  int val4 ;
13879  int ecode4 = 0 ;
13880  int val5 ;
13881  int ecode5 = 0 ;
13882  double val6 ;
13883  int ecode6 = 0 ;
13884  PLFLT temp7 ;
13885  int res7 = SWIG_TMPOBJ ;
13886  octave_value_list _out;
13887  octave_value_list *_outp=&_out;
13888  octave_value _outv;
13889 
13890  arg7 = &temp7;
13891  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
13892  SWIG_fail;
13893  }
13894  ecode1 = SWIG_AsVal_int(args(0), &val1);
13895  if (!SWIG_IsOK(ecode1)) {
13896  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
13897  }
13898  arg1 = (PLINT)(val1);
13899  ecode2 = SWIG_AsVal_int(args(1), &val2);
13900  if (!SWIG_IsOK(ecode2)) {
13901  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
13902  }
13903  arg2 = (PLINT)(val2);
13904  ecode3 = SWIG_AsVal_int(args(2), &val3);
13905  if (!SWIG_IsOK(ecode3)) {
13906  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
13907  }
13908  arg3 = (PLINT)(val3);
13909  ecode4 = SWIG_AsVal_int(args(3), &val4);
13910  if (!SWIG_IsOK(ecode4)) {
13911  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
13912  }
13913  arg4 = (PLINT)(val4);
13914  ecode5 = SWIG_AsVal_int(args(4), &val5);
13915  if (!SWIG_IsOK(ecode5)) {
13916  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
13917  }
13918  arg5 = (PLINT)(val5);
13919  ecode6 = SWIG_AsVal_double(args(5), &val6);
13920  if (!SWIG_IsOK(ecode6)) {
13921  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
13922  }
13923  arg6 = (PLFLT)(val6);
13924  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13925  _outv = octave_value();
13926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13927  if (SWIG_IsTmpObj(res7)) {
13928  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
13929  } else {
13930  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13931  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
13932  }
13933 fail:
13934  return _out;
13935 }
13936 
13937 
13938 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
13939  PLINT arg1 ;
13940  PLBOOL arg2 ;
13941  int val1 ;
13942  int ecode1 = 0 ;
13943  int val2 ;
13944  int ecode2 = 0 ;
13945  octave_value_list _out;
13946  octave_value_list *_outp=&_out;
13947  octave_value _outv;
13948 
13949  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
13950  SWIG_fail;
13951  }
13952  ecode1 = SWIG_AsVal_int(args(0), &val1);
13953  if (!SWIG_IsOK(ecode1)) {
13954  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
13955  }
13956  arg1 = (PLINT)(val1);
13957  ecode2 = SWIG_AsVal_int(args(1), &val2);
13958  if (!SWIG_IsOK(ecode2)) {
13959  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
13960  }
13961  arg2 = (PLBOOL)(val2);
13962  plcpstrm(arg1,arg2);
13963  _outv = octave_value();
13964  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13965 fail:
13966  return _out;
13967 }
13968 
13969 
13970 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
13971  octave_value_list _out;
13972  octave_value_list *_outp=&_out;
13973  octave_value _outv;
13974 
13975  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
13976  SWIG_fail;
13977  }
13978  plend();
13979  _outv = octave_value();
13980  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13981 fail:
13982  return _out;
13983 }
13984 
13985 
13986 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
13987  octave_value_list _out;
13988  octave_value_list *_outp=&_out;
13989  octave_value _outv;
13990 
13991  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
13992  SWIG_fail;
13993  }
13994  plend1();
13995  _outv = octave_value();
13996  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13997 fail:
13998  return _out;
13999 }
14000 
14001 
14002 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
14003  PLFLT arg1 ;
14004  PLFLT arg2 ;
14005  PLFLT arg3 ;
14006  PLFLT arg4 ;
14007  PLINT arg5 ;
14008  PLINT arg6 ;
14009  double val1 ;
14010  int ecode1 = 0 ;
14011  double val2 ;
14012  int ecode2 = 0 ;
14013  double val3 ;
14014  int ecode3 = 0 ;
14015  double val4 ;
14016  int ecode4 = 0 ;
14017  int val5 ;
14018  int ecode5 = 0 ;
14019  int val6 ;
14020  int ecode6 = 0 ;
14021  octave_value_list _out;
14022  octave_value_list *_outp=&_out;
14023  octave_value _outv;
14024 
14025  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
14026  SWIG_fail;
14027  }
14028  ecode1 = SWIG_AsVal_double(args(0), &val1);
14029  if (!SWIG_IsOK(ecode1)) {
14030  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
14031  }
14032  arg1 = (PLFLT)(val1);
14033  ecode2 = SWIG_AsVal_double(args(1), &val2);
14034  if (!SWIG_IsOK(ecode2)) {
14035  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
14036  }
14037  arg2 = (PLFLT)(val2);
14038  ecode3 = SWIG_AsVal_double(args(2), &val3);
14039  if (!SWIG_IsOK(ecode3)) {
14040  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
14041  }
14042  arg3 = (PLFLT)(val3);
14043  ecode4 = SWIG_AsVal_double(args(3), &val4);
14044  if (!SWIG_IsOK(ecode4)) {
14045  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
14046  }
14047  arg4 = (PLFLT)(val4);
14048  ecode5 = SWIG_AsVal_int(args(4), &val5);
14049  if (!SWIG_IsOK(ecode5)) {
14050  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
14051  }
14052  arg5 = (PLINT)(val5);
14053  ecode6 = SWIG_AsVal_int(args(5), &val6);
14054  if (!SWIG_IsOK(ecode6)) {
14055  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
14056  }
14057  arg6 = (PLINT)(val6);
14058  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
14059  _outv = octave_value();
14060  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14061 fail:
14062  return _out;
14063 }
14064 
14065 
14066 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
14067  PLFLT arg1 ;
14068  PLFLT arg2 ;
14069  PLFLT arg3 ;
14070  PLFLT arg4 ;
14071  PLINT arg5 ;
14072  PLINT arg6 ;
14073  double val1 ;
14074  int ecode1 = 0 ;
14075  double val2 ;
14076  int ecode2 = 0 ;
14077  double val3 ;
14078  int ecode3 = 0 ;
14079  double val4 ;
14080  int ecode4 = 0 ;
14081  int val5 ;
14082  int ecode5 = 0 ;
14083  int val6 ;
14084  int ecode6 = 0 ;
14085  octave_value_list _out;
14086  octave_value_list *_outp=&_out;
14087  octave_value _outv;
14088 
14089  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
14090  SWIG_fail;
14091  }
14092  ecode1 = SWIG_AsVal_double(args(0), &val1);
14093  if (!SWIG_IsOK(ecode1)) {
14094  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
14095  }
14096  arg1 = (PLFLT)(val1);
14097  ecode2 = SWIG_AsVal_double(args(1), &val2);
14098  if (!SWIG_IsOK(ecode2)) {
14099  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
14100  }
14101  arg2 = (PLFLT)(val2);
14102  ecode3 = SWIG_AsVal_double(args(2), &val3);
14103  if (!SWIG_IsOK(ecode3)) {
14104  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
14105  }
14106  arg3 = (PLFLT)(val3);
14107  ecode4 = SWIG_AsVal_double(args(3), &val4);
14108  if (!SWIG_IsOK(ecode4)) {
14109  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
14110  }
14111  arg4 = (PLFLT)(val4);
14112  ecode5 = SWIG_AsVal_int(args(4), &val5);
14113  if (!SWIG_IsOK(ecode5)) {
14114  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
14115  }
14116  arg5 = (PLINT)(val5);
14117  ecode6 = SWIG_AsVal_int(args(5), &val6);
14118  if (!SWIG_IsOK(ecode6)) {
14119  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
14120  }
14121  arg6 = (PLINT)(val6);
14122  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
14123  _outv = octave_value();
14124  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14125 fail:
14126  return _out;
14127 }
14128 
14129 
14130 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
14131  octave_value_list _out;
14132  octave_value_list *_outp=&_out;
14133  octave_value _outv;
14134 
14135  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
14136  SWIG_fail;
14137  }
14138  pleop();
14139  _outv = octave_value();
14140  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14141 fail:
14142  return _out;
14143 }
14144 
14145 
14146 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
14147  PLINT arg1 ;
14148  PLFLT *arg2 = (PLFLT *) 0 ;
14149  PLFLT *arg3 = (PLFLT *) 0 ;
14150  PLFLT *arg4 = (PLFLT *) 0 ;
14151  Matrix temp1 ;
14152  Matrix temp3 ;
14153  Matrix temp4 ;
14154  octave_value_list _out;
14155  octave_value_list *_outp=&_out;
14156  octave_value _outv;
14157 
14158  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
14159  SWIG_fail;
14160  }
14161  {
14162  if ( _n_dims( args(0) ) > 1 )
14163  {
14164  error( "argument must be a scalar or vector" ); SWIG_fail;
14165  }
14166  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14167  temp1 = args(0).matrix_value();
14168  arg2 = &temp1( 0, 0 );
14169  }
14170  {
14171  if ( _n_dims( args(1) ) > 1 )
14172  {
14173  error( "argument must be a scalar or vector" ); SWIG_fail;
14174  }
14175  if ( _dim( args(1), 0 ) != Alen )
14176  {
14177  error( "argument vectors must be same length" ); SWIG_fail;
14178  }
14179  temp3 = args(1).matrix_value();
14180  arg3 = &temp3( 0, 0 );
14181  }
14182  {
14183  if ( _n_dims( args(2) ) > 1 )
14184  {
14185  error( "argument must be a scalar or vector" ); SWIG_fail;
14186  }
14187  if ( _dim( args(2), 0 ) != Alen )
14188  {
14189  error( "argument vectors must be same length" ); SWIG_fail;
14190  }
14191  temp4 = args(2).matrix_value();
14192  arg4 = &temp4( 0, 0 );
14193  }
14194  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14195  _outv = octave_value();
14196  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14197  {
14198 
14199  }
14200  {
14201 
14202  }
14203  {
14204 
14205  }
14206 fail:
14207  return _out;
14208 }
14209 
14210 
14211 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
14212  PLINT arg1 ;
14213  PLFLT *arg2 = (PLFLT *) 0 ;
14214  PLFLT *arg3 = (PLFLT *) 0 ;
14215  PLFLT *arg4 = (PLFLT *) 0 ;
14216  Matrix temp1 ;
14217  Matrix temp3 ;
14218  Matrix temp4 ;
14219  octave_value_list _out;
14220  octave_value_list *_outp=&_out;
14221  octave_value _outv;
14222 
14223  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
14224  SWIG_fail;
14225  }
14226  {
14227  if ( _n_dims( args(0) ) > 1 )
14228  {
14229  error( "argument must be a scalar or vector" ); SWIG_fail;
14230  }
14231  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14232  temp1 = args(0).matrix_value();
14233  arg2 = &temp1( 0, 0 );
14234  }
14235  {
14236  if ( _n_dims( args(1) ) > 1 )
14237  {
14238  error( "argument must be a scalar or vector" ); SWIG_fail;
14239  }
14240  if ( _dim( args(1), 0 ) != Alen )
14241  {
14242  error( "argument vectors must be same length" ); SWIG_fail;
14243  }
14244  temp3 = args(1).matrix_value();
14245  arg3 = &temp3( 0, 0 );
14246  }
14247  {
14248  if ( _n_dims( args(2) ) > 1 )
14249  {
14250  error( "argument must be a scalar or vector" ); SWIG_fail;
14251  }
14252  if ( _dim( args(2), 0 ) != Alen )
14253  {
14254  error( "argument vectors must be same length" ); SWIG_fail;
14255  }
14256  temp4 = args(2).matrix_value();
14257  arg4 = &temp4( 0, 0 );
14258  }
14259  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14260  _outv = octave_value();
14261  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14262  {
14263 
14264  }
14265  {
14266 
14267  }
14268  {
14269 
14270  }
14271 fail:
14272  return _out;
14273 }
14274 
14275 
14276 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
14277  octave_value_list _out;
14278  octave_value_list *_outp=&_out;
14279  octave_value _outv;
14280 
14281  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
14282  SWIG_fail;
14283  }
14284  plfamadv();
14285  _outv = octave_value();
14286  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14287 fail:
14288  return _out;
14289 }
14290 
14291 
14292 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
14293  PLINT arg1 ;
14294  PLFLT *arg2 = (PLFLT *) 0 ;
14295  PLFLT *arg3 = (PLFLT *) 0 ;
14296  Matrix temp1 ;
14297  Matrix temp3 ;
14298  octave_value_list _out;
14299  octave_value_list *_outp=&_out;
14300  octave_value _outv;
14301 
14302  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
14303  SWIG_fail;
14304  }
14305  {
14306  if ( _n_dims( args(0) ) > 1 )
14307  {
14308  error( "argument must be a scalar or vector" ); SWIG_fail;
14309  }
14310  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14311  temp1 = args(0).matrix_value();
14312  arg2 = &temp1( 0, 0 );
14313  }
14314  {
14315  if ( _n_dims( args(1) ) > 1 )
14316  {
14317  error( "argument must be a scalar or vector" ); SWIG_fail;
14318  }
14319  if ( _dim( args(1), 0 ) != Alen )
14320  {
14321  error( "argument vectors must be same length" ); SWIG_fail;
14322  }
14323  temp3 = args(1).matrix_value();
14324  arg3 = &temp3( 0, 0 );
14325  }
14326  plfill(arg1,(double const *)arg2,(double const *)arg3);
14327  _outv = octave_value();
14328  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14329  {
14330 
14331  }
14332  {
14333 
14334  }
14335 fail:
14336  return _out;
14337 }
14338 
14339 
14340 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
14341  PLINT arg1 ;
14342  PLFLT *arg2 = (PLFLT *) 0 ;
14343  PLFLT *arg3 = (PLFLT *) 0 ;
14344  PLFLT *arg4 = (PLFLT *) 0 ;
14345  Matrix temp1 ;
14346  Matrix temp3 ;
14347  Matrix temp4 ;
14348  octave_value_list _out;
14349  octave_value_list *_outp=&_out;
14350  octave_value _outv;
14351 
14352  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
14353  SWIG_fail;
14354  }
14355  {
14356  if ( _n_dims( args(0) ) > 1 )
14357  {
14358  error( "argument must be a scalar or vector" ); SWIG_fail;
14359  }
14360  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14361  temp1 = args(0).matrix_value();
14362  arg2 = &temp1( 0, 0 );
14363  }
14364  {
14365  if ( _n_dims( args(1) ) > 1 )
14366  {
14367  error( "argument must be a scalar or vector" ); SWIG_fail;
14368  }
14369  if ( _dim( args(1), 0 ) != Alen )
14370  {
14371  error( "argument vectors must be same length" ); SWIG_fail;
14372  }
14373  temp3 = args(1).matrix_value();
14374  arg3 = &temp3( 0, 0 );
14375  }
14376  {
14377  if ( _n_dims( args(2) ) > 1 )
14378  {
14379  error( "argument must be a scalar or vector" ); SWIG_fail;
14380  }
14381  if ( _dim( args(2), 0 ) != Alen )
14382  {
14383  error( "argument vectors must be same length" ); SWIG_fail;
14384  }
14385  temp4 = args(2).matrix_value();
14386  arg4 = &temp4( 0, 0 );
14387  }
14388  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14389  _outv = octave_value();
14390  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14391  {
14392 
14393  }
14394  {
14395 
14396  }
14397  {
14398 
14399  }
14400 fail:
14401  return _out;
14402 }
14403 
14404 
14405 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
14406  PLINT arg1 ;
14407  PLFLT *arg2 = (PLFLT *) 0 ;
14408  PLFLT *arg3 = (PLFLT *) 0 ;
14409  PLFLT arg4 ;
14410  Matrix temp1 ;
14411  Matrix temp3 ;
14412  double val4 ;
14413  int ecode4 = 0 ;
14414  octave_value_list _out;
14415  octave_value_list *_outp=&_out;
14416  octave_value _outv;
14417 
14418  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
14419  SWIG_fail;
14420  }
14421  {
14422  if ( _n_dims( args(0) ) > 1 )
14423  {
14424  error( "argument must be a scalar or vector" ); SWIG_fail;
14425  }
14426  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14427  temp1 = args(0).matrix_value();
14428  arg2 = &temp1( 0, 0 );
14429  }
14430  {
14431  if ( _n_dims( args(1) ) > 1 )
14432  {
14433  error( "argument must be a scalar or vector" ); SWIG_fail;
14434  }
14435  if ( _dim( args(1), 0 ) != Alen )
14436  {
14437  error( "argument vectors must be same length" ); SWIG_fail;
14438  }
14439  temp3 = args(1).matrix_value();
14440  arg3 = &temp3( 0, 0 );
14441  }
14442  ecode4 = SWIG_AsVal_double(args(2), &val4);
14443  if (!SWIG_IsOK(ecode4)) {
14444  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
14445  }
14446  arg4 = (PLFLT)(val4);
14447  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
14448  _outv = octave_value();
14449  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14450  {
14451 
14452  }
14453  {
14454 
14455  }
14456 fail:
14457  return _out;
14458 }
14459 
14460 
14461 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
14462  octave_value_list _out;
14463  octave_value_list *_outp=&_out;
14464  octave_value _outv;
14465 
14466  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
14467  SWIG_fail;
14468  }
14469  plflush();
14470  _outv = octave_value();
14471  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14472 fail:
14473  return _out;
14474 }
14475 
14476 
14477 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
14478  PLINT arg1 ;
14479  int val1 ;
14480  int ecode1 = 0 ;
14481  octave_value_list _out;
14482  octave_value_list *_outp=&_out;
14483  octave_value _outv;
14484 
14485  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
14486  SWIG_fail;
14487  }
14488  ecode1 = SWIG_AsVal_int(args(0), &val1);
14489  if (!SWIG_IsOK(ecode1)) {
14490  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
14491  }
14492  arg1 = (PLINT)(val1);
14493  plfont(arg1);
14494  _outv = octave_value();
14495  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14496 fail:
14497  return _out;
14498 }
14499 
14500 
14501 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
14502  PLINT arg1 ;
14503  int val1 ;
14504  int ecode1 = 0 ;
14505  octave_value_list _out;
14506  octave_value_list *_outp=&_out;
14507  octave_value _outv;
14508 
14509  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
14510  SWIG_fail;
14511  }
14512  ecode1 = SWIG_AsVal_int(args(0), &val1);
14513  if (!SWIG_IsOK(ecode1)) {
14514  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
14515  }
14516  arg1 = (PLINT)(val1);
14517  plfontld(arg1);
14518  _outv = octave_value();
14519  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14520 fail:
14521  return _out;
14522 }
14523 
14524 
14525 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
14526  PLFLT *arg1 = (PLFLT *) 0 ;
14527  PLFLT *arg2 = (PLFLT *) 0 ;
14528  PLFLT temp1 ;
14529  int res1 = SWIG_TMPOBJ ;
14530  PLFLT temp2 ;
14531  int res2 = SWIG_TMPOBJ ;
14532  octave_value_list _out;
14533  octave_value_list *_outp=&_out;
14534  octave_value _outv;
14535 
14536  arg1 = &temp1;
14537  arg2 = &temp2;
14538  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
14539  SWIG_fail;
14540  }
14541  plgchr(arg1,arg2);
14542  _outv = octave_value();
14543  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14544  if (SWIG_IsTmpObj(res1)) {
14545  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14546  } else {
14547  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14548  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14549  }
14550  if (SWIG_IsTmpObj(res2)) {
14551  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14552  } else {
14553  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14554  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14555  }
14556 fail:
14557  return _out;
14558 }
14559 
14560 
14561 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
14562  PLINT arg1 ;
14563  PLINT *arg2 = (PLINT *) 0 ;
14564  PLINT *arg3 = (PLINT *) 0 ;
14565  PLINT *arg4 = (PLINT *) 0 ;
14566  int val1 ;
14567  int ecode1 = 0 ;
14568  PLINT temp2 ;
14569  int res2 = SWIG_TMPOBJ ;
14570  PLINT temp3 ;
14571  int res3 = SWIG_TMPOBJ ;
14572  PLINT temp4 ;
14573  int res4 = SWIG_TMPOBJ ;
14574  octave_value_list _out;
14575  octave_value_list *_outp=&_out;
14576  octave_value _outv;
14577 
14578  arg2 = &temp2;
14579  arg3 = &temp3;
14580  arg4 = &temp4;
14581  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
14582  SWIG_fail;
14583  }
14584  ecode1 = SWIG_AsVal_int(args(0), &val1);
14585  if (!SWIG_IsOK(ecode1)) {
14586  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
14587  }
14588  arg1 = (PLINT)(val1);
14589  plgcol0(arg1,arg2,arg3,arg4);
14590  _outv = octave_value();
14591  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14592  if (SWIG_IsTmpObj(res2)) {
14593  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14594  } else {
14595  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14596  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14597  }
14598  if (SWIG_IsTmpObj(res3)) {
14599  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14600  } else {
14601  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14602  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14603  }
14604  if (SWIG_IsTmpObj(res4)) {
14605  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
14606  } else {
14607  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14608  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
14609  }
14610 fail:
14611  return _out;
14612 }
14613 
14614 
14615 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
14616  PLINT arg1 ;
14617  PLINT *arg2 = (PLINT *) 0 ;
14618  PLINT *arg3 = (PLINT *) 0 ;
14619  PLINT *arg4 = (PLINT *) 0 ;
14620  PLFLT *arg5 = (PLFLT *) 0 ;
14621  int val1 ;
14622  int ecode1 = 0 ;
14623  PLINT temp2 ;
14624  int res2 = SWIG_TMPOBJ ;
14625  PLINT temp3 ;
14626  int res3 = SWIG_TMPOBJ ;
14627  PLINT temp4 ;
14628  int res4 = SWIG_TMPOBJ ;
14629  PLFLT temp5 ;
14630  int res5 = SWIG_TMPOBJ ;
14631  octave_value_list _out;
14632  octave_value_list *_outp=&_out;
14633  octave_value _outv;
14634 
14635  arg2 = &temp2;
14636  arg3 = &temp3;
14637  arg4 = &temp4;
14638  arg5 = &temp5;
14639  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
14640  SWIG_fail;
14641  }
14642  ecode1 = SWIG_AsVal_int(args(0), &val1);
14643  if (!SWIG_IsOK(ecode1)) {
14644  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
14645  }
14646  arg1 = (PLINT)(val1);
14647  plgcol0a(arg1,arg2,arg3,arg4,arg5);
14648  _outv = octave_value();
14649  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14650  if (SWIG_IsTmpObj(res2)) {
14651  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14652  } else {
14653  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14654  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14655  }
14656  if (SWIG_IsTmpObj(res3)) {
14657  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14658  } else {
14659  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14660  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14661  }
14662  if (SWIG_IsTmpObj(res4)) {
14663  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
14664  } else {
14665  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14666  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
14667  }
14668  if (SWIG_IsTmpObj(res5)) {
14669  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
14670  } else {
14671  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14672  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14673  }
14674 fail:
14675  return _out;
14676 }
14677 
14678 
14679 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
14680  PLINT *arg1 = (PLINT *) 0 ;
14681  PLINT *arg2 = (PLINT *) 0 ;
14682  PLINT *arg3 = (PLINT *) 0 ;
14683  PLINT temp1 ;
14684  int res1 = SWIG_TMPOBJ ;
14685  PLINT temp2 ;
14686  int res2 = SWIG_TMPOBJ ;
14687  PLINT temp3 ;
14688  int res3 = SWIG_TMPOBJ ;
14689  octave_value_list _out;
14690  octave_value_list *_outp=&_out;
14691  octave_value _outv;
14692 
14693  arg1 = &temp1;
14694  arg2 = &temp2;
14695  arg3 = &temp3;
14696  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
14697  SWIG_fail;
14698  }
14699  plgcolbg(arg1,arg2,arg3);
14700  _outv = octave_value();
14701  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14702  if (SWIG_IsTmpObj(res1)) {
14703  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14704  } else {
14705  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14706  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14707  }
14708  if (SWIG_IsTmpObj(res2)) {
14709  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14710  } else {
14711  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14712  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14713  }
14714  if (SWIG_IsTmpObj(res3)) {
14715  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14716  } else {
14717  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14718  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14719  }
14720 fail:
14721  return _out;
14722 }
14723 
14724 
14725 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
14726  PLINT *arg1 = (PLINT *) 0 ;
14727  PLINT *arg2 = (PLINT *) 0 ;
14728  PLINT *arg3 = (PLINT *) 0 ;
14729  PLFLT *arg4 = (PLFLT *) 0 ;
14730  PLINT temp1 ;
14731  int res1 = SWIG_TMPOBJ ;
14732  PLINT temp2 ;
14733  int res2 = SWIG_TMPOBJ ;
14734  PLINT temp3 ;
14735  int res3 = SWIG_TMPOBJ ;
14736  PLFLT temp4 ;
14737  int res4 = SWIG_TMPOBJ ;
14738  octave_value_list _out;
14739  octave_value_list *_outp=&_out;
14740  octave_value _outv;
14741 
14742  arg1 = &temp1;
14743  arg2 = &temp2;
14744  arg3 = &temp3;
14745  arg4 = &temp4;
14746  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
14747  SWIG_fail;
14748  }
14749  plgcolbga(arg1,arg2,arg3,arg4);
14750  _outv = octave_value();
14751  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14752  if (SWIG_IsTmpObj(res1)) {
14753  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14754  } else {
14755  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14756  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14757  }
14758  if (SWIG_IsTmpObj(res2)) {
14759  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14760  } else {
14761  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14762  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14763  }
14764  if (SWIG_IsTmpObj(res3)) {
14765  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14766  } else {
14767  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14768  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14769  }
14770  if (SWIG_IsTmpObj(res4)) {
14771  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14772  } else {
14773  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14774  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14775  }
14776 fail:
14777  return _out;
14778 }
14779 
14780 
14781 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
14782  PLINT *arg1 = (PLINT *) 0 ;
14783  PLINT temp1 ;
14784  int res1 = SWIG_TMPOBJ ;
14785  octave_value_list _out;
14786  octave_value_list *_outp=&_out;
14787  octave_value _outv;
14788 
14789  arg1 = &temp1;
14790  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
14791  SWIG_fail;
14792  }
14793  plgcompression(arg1);
14794  _outv = octave_value();
14795  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14796  if (SWIG_IsTmpObj(res1)) {
14797  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14798  } else {
14799  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14800  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14801  }
14802 fail:
14803  return _out;
14804 }
14805 
14806 
14807 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
14808  char *arg1 = (char *) 0 ;
14809  octave_value_list retval1 ;
14810  octave_value_list _out;
14811  octave_value_list *_outp=&_out;
14812  octave_value _outv;
14813 
14814  {
14815  // Check if version >= 3.4.0
14816 # if OCTAVE_API_VERSION_NUMBER < 45
14817  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
14818 # else
14819  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
14820 # endif
14821  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
14822  }
14823  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
14824  SWIG_fail;
14825  }
14826  plgdev(arg1);
14827  _outv = octave_value();
14828  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14829  {
14830  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
14831  }
14832 fail:
14833  return _out;
14834 }
14835 
14836 
14837 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
14838  PLFLT *arg1 = (PLFLT *) 0 ;
14839  PLFLT *arg2 = (PLFLT *) 0 ;
14840  PLFLT *arg3 = (PLFLT *) 0 ;
14841  PLFLT *arg4 = (PLFLT *) 0 ;
14842  PLFLT temp1 ;
14843  int res1 = SWIG_TMPOBJ ;
14844  PLFLT temp2 ;
14845  int res2 = SWIG_TMPOBJ ;
14846  PLFLT temp3 ;
14847  int res3 = SWIG_TMPOBJ ;
14848  PLFLT temp4 ;
14849  int res4 = SWIG_TMPOBJ ;
14850  octave_value_list _out;
14851  octave_value_list *_outp=&_out;
14852  octave_value _outv;
14853 
14854  arg1 = &temp1;
14855  arg2 = &temp2;
14856  arg3 = &temp3;
14857  arg4 = &temp4;
14858  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
14859  SWIG_fail;
14860  }
14861  plgdidev(arg1,arg2,arg3,arg4);
14862  _outv = octave_value();
14863  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14864  if (SWIG_IsTmpObj(res1)) {
14865  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14866  } else {
14867  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14868  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14869  }
14870  if (SWIG_IsTmpObj(res2)) {
14871  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14872  } else {
14873  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14874  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14875  }
14876  if (SWIG_IsTmpObj(res3)) {
14877  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
14878  } else {
14879  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14880  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
14881  }
14882  if (SWIG_IsTmpObj(res4)) {
14883  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14884  } else {
14885  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14886  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14887  }
14888 fail:
14889  return _out;
14890 }
14891 
14892 
14893 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
14894  PLFLT *arg1 = (PLFLT *) 0 ;
14895  PLFLT temp1 ;
14896  int res1 = SWIG_TMPOBJ ;
14897  octave_value_list _out;
14898  octave_value_list *_outp=&_out;
14899  octave_value _outv;
14900 
14901  arg1 = &temp1;
14902  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
14903  SWIG_fail;
14904  }
14905  plgdiori(arg1);
14906  _outv = octave_value();
14907  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14908  if (SWIG_IsTmpObj(res1)) {
14909  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14910  } else {
14911  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14912  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14913  }
14914 fail:
14915  return _out;
14916 }
14917 
14918 
14919 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
14920  PLFLT *arg1 = (PLFLT *) 0 ;
14921  PLFLT *arg2 = (PLFLT *) 0 ;
14922  PLFLT *arg3 = (PLFLT *) 0 ;
14923  PLFLT *arg4 = (PLFLT *) 0 ;
14924  PLFLT temp1 ;
14925  int res1 = SWIG_TMPOBJ ;
14926  PLFLT temp2 ;
14927  int res2 = SWIG_TMPOBJ ;
14928  PLFLT temp3 ;
14929  int res3 = SWIG_TMPOBJ ;
14930  PLFLT temp4 ;
14931  int res4 = SWIG_TMPOBJ ;
14932  octave_value_list _out;
14933  octave_value_list *_outp=&_out;
14934  octave_value _outv;
14935 
14936  arg1 = &temp1;
14937  arg2 = &temp2;
14938  arg3 = &temp3;
14939  arg4 = &temp4;
14940  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
14941  SWIG_fail;
14942  }
14943  plgdiplt(arg1,arg2,arg3,arg4);
14944  _outv = octave_value();
14945  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14946  if (SWIG_IsTmpObj(res1)) {
14947  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14948  } else {
14949  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14950  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14951  }
14952  if (SWIG_IsTmpObj(res2)) {
14953  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14954  } else {
14955  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14956  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14957  }
14958  if (SWIG_IsTmpObj(res3)) {
14959  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
14960  } else {
14961  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14962  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
14963  }
14964  if (SWIG_IsTmpObj(res4)) {
14965  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14966  } else {
14967  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14968  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14969  }
14970 fail:
14971  return _out;
14972 }
14973 
14974 
14975 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
14976  PLINT *arg1 = (PLINT *) 0 ;
14977  PLINT *arg2 = (PLINT *) 0 ;
14978  PLINT *arg3 = (PLINT *) 0 ;
14979  PLINT temp1 ;
14980  int res1 = SWIG_TMPOBJ ;
14981  PLINT temp2 ;
14982  int res2 = SWIG_TMPOBJ ;
14983  PLINT temp3 ;
14984  int res3 = SWIG_TMPOBJ ;
14985  octave_value_list _out;
14986  octave_value_list *_outp=&_out;
14987  octave_value _outv;
14988 
14989  arg1 = &temp1;
14990  arg2 = &temp2;
14991  arg3 = &temp3;
14992  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
14993  SWIG_fail;
14994  }
14995  plgfam(arg1,arg2,arg3);
14996  _outv = octave_value();
14997  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14998  if (SWIG_IsTmpObj(res1)) {
14999  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15000  } else {
15001  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15002  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15003  }
15004  if (SWIG_IsTmpObj(res2)) {
15005  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15006  } else {
15007  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15008  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15009  }
15010  if (SWIG_IsTmpObj(res3)) {
15011  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15012  } else {
15013  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15014  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15015  }
15016 fail:
15017  return _out;
15018 }
15019 
15020 
15021 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
15022  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
15023  PLUNICODE temp1 ;
15024  int res1 = SWIG_TMPOBJ ;
15025  octave_value_list _out;
15026  octave_value_list *_outp=&_out;
15027  octave_value _outv;
15028 
15029  arg1 = &temp1;
15030  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
15031  SWIG_fail;
15032  }
15033  plgfci(arg1);
15034  _outv = octave_value();
15035  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15036  if (SWIG_IsTmpObj(res1)) {
15037  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
15038  } else {
15039  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15040  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
15041  }
15042 fail:
15043  return _out;
15044 }
15045 
15046 
15047 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
15048  char *arg1 = (char *) 0 ;
15049  octave_value_list retval1 ;
15050  octave_value_list _out;
15051  octave_value_list *_outp=&_out;
15052  octave_value _outv;
15053 
15054  {
15055  // Check if version >= 3.4.0
15056 # if OCTAVE_API_VERSION_NUMBER < 45
15057  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15058 # else
15059  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15060 # endif
15061  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15062  }
15063  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
15064  SWIG_fail;
15065  }
15066  plgfnam(arg1);
15067  _outv = octave_value();
15068  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15069  {
15070  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15071  }
15072 fail:
15073  return _out;
15074 }
15075 
15076 
15077 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
15078  PLINT *arg1 = (PLINT *) 0 ;
15079  PLINT *arg2 = (PLINT *) 0 ;
15080  PLINT *arg3 = (PLINT *) 0 ;
15081  PLINT temp1 ;
15082  int res1 = SWIG_TMPOBJ ;
15083  PLINT temp2 ;
15084  int res2 = SWIG_TMPOBJ ;
15085  PLINT temp3 ;
15086  int res3 = SWIG_TMPOBJ ;
15087  octave_value_list _out;
15088  octave_value_list *_outp=&_out;
15089  octave_value _outv;
15090 
15091  arg1 = &temp1;
15092  arg2 = &temp2;
15093  arg3 = &temp3;
15094  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
15095  SWIG_fail;
15096  }
15097  plgfont(arg1,arg2,arg3);
15098  _outv = octave_value();
15099  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15100  if (SWIG_IsTmpObj(res1)) {
15101  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15102  } else {
15103  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15104  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15105  }
15106  if (SWIG_IsTmpObj(res2)) {
15107  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15108  } else {
15109  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15110  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15111  }
15112  if (SWIG_IsTmpObj(res3)) {
15113  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15114  } else {
15115  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15116  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15117  }
15118 fail:
15119  return _out;
15120 }
15121 
15122 
15123 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
15124  PLINT *arg1 = (PLINT *) 0 ;
15125  PLINT temp1 ;
15126  int res1 = SWIG_TMPOBJ ;
15127  octave_value_list _out;
15128  octave_value_list *_outp=&_out;
15129  octave_value _outv;
15130 
15131  arg1 = &temp1;
15132  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
15133  SWIG_fail;
15134  }
15135  plglevel(arg1);
15136  _outv = octave_value();
15137  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15138  if (SWIG_IsTmpObj(res1)) {
15139  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15140  } else {
15141  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15142  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15143  }
15144 fail:
15145  return _out;
15146 }
15147 
15148 
15149 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
15150  PLFLT *arg1 = (PLFLT *) 0 ;
15151  PLFLT *arg2 = (PLFLT *) 0 ;
15152  PLINT *arg3 = (PLINT *) 0 ;
15153  PLINT *arg4 = (PLINT *) 0 ;
15154  PLINT *arg5 = (PLINT *) 0 ;
15155  PLINT *arg6 = (PLINT *) 0 ;
15156  PLFLT temp1 ;
15157  int res1 = SWIG_TMPOBJ ;
15158  PLFLT temp2 ;
15159  int res2 = SWIG_TMPOBJ ;
15160  PLINT temp3 ;
15161  int res3 = SWIG_TMPOBJ ;
15162  PLINT temp4 ;
15163  int res4 = SWIG_TMPOBJ ;
15164  PLINT temp5 ;
15165  int res5 = SWIG_TMPOBJ ;
15166  PLINT temp6 ;
15167  int res6 = SWIG_TMPOBJ ;
15168  octave_value_list _out;
15169  octave_value_list *_outp=&_out;
15170  octave_value _outv;
15171 
15172  arg1 = &temp1;
15173  arg2 = &temp2;
15174  arg3 = &temp3;
15175  arg4 = &temp4;
15176  arg5 = &temp5;
15177  arg6 = &temp6;
15178  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
15179  SWIG_fail;
15180  }
15181  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
15182  _outv = octave_value();
15183  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15184  if (SWIG_IsTmpObj(res1)) {
15185  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15186  } else {
15187  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15188  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15189  }
15190  if (SWIG_IsTmpObj(res2)) {
15191  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15192  } else {
15193  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15194  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15195  }
15196  if (SWIG_IsTmpObj(res3)) {
15197  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15198  } else {
15199  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15200  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15201  }
15202  if (SWIG_IsTmpObj(res4)) {
15203  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15204  } else {
15205  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15206  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15207  }
15208  if (SWIG_IsTmpObj(res5)) {
15209  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15210  } else {
15211  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15212  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15213  }
15214  if (SWIG_IsTmpObj(res6)) {
15215  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
15216  } else {
15217  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15218  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
15219  }
15220 fail:
15221  return _out;
15222 }
15223 
15224 
15225 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
15226  octave_value_list _out;
15227  octave_value_list *_outp=&_out;
15228  octave_value _outv;
15229 
15230  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
15231  SWIG_fail;
15232  }
15233  plgra();
15234  _outv = octave_value();
15235  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15236 fail:
15237  return _out;
15238 }
15239 
15240 
15241 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
15242  PLFLT *arg1 = (PLFLT *) 0 ;
15243  PLFLT *arg2 = (PLFLT *) 0 ;
15244  PLFLT *arg3 = (PLFLT *) 0 ;
15245  PLFLT *arg4 = (PLFLT *) 0 ;
15246  PLFLT temp1 ;
15247  int res1 = SWIG_TMPOBJ ;
15248  PLFLT temp2 ;
15249  int res2 = SWIG_TMPOBJ ;
15250  PLFLT temp3 ;
15251  int res3 = SWIG_TMPOBJ ;
15252  PLFLT temp4 ;
15253  int res4 = SWIG_TMPOBJ ;
15254  octave_value_list _out;
15255  octave_value_list *_outp=&_out;
15256  octave_value _outv;
15257 
15258  arg1 = &temp1;
15259  arg2 = &temp2;
15260  arg3 = &temp3;
15261  arg4 = &temp4;
15262  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
15263  SWIG_fail;
15264  }
15265  plgspa(arg1,arg2,arg3,arg4);
15266  _outv = octave_value();
15267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15268  if (SWIG_IsTmpObj(res1)) {
15269  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15270  } else {
15271  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15272  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15273  }
15274  if (SWIG_IsTmpObj(res2)) {
15275  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15276  } else {
15277  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15278  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15279  }
15280  if (SWIG_IsTmpObj(res3)) {
15281  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15282  } else {
15283  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15284  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15285  }
15286  if (SWIG_IsTmpObj(res4)) {
15287  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15288  } else {
15289  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15290  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15291  }
15292 fail:
15293  return _out;
15294 }
15295 
15296 
15297 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
15298  PLINT *arg1 = (PLINT *) 0 ;
15299  PLINT temp1 ;
15300  int res1 = SWIG_TMPOBJ ;
15301  octave_value_list _out;
15302  octave_value_list *_outp=&_out;
15303  octave_value _outv;
15304 
15305  arg1 = &temp1;
15306  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
15307  SWIG_fail;
15308  }
15309  plgstrm(arg1);
15310  _outv = octave_value();
15311  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15312  if (SWIG_IsTmpObj(res1)) {
15313  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15314  } else {
15315  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15316  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15317  }
15318 fail:
15319  return _out;
15320 }
15321 
15322 
15323 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
15324  char *arg1 = (char *) 0 ;
15325  octave_value_list retval1 ;
15326  octave_value_list _out;
15327  octave_value_list *_outp=&_out;
15328  octave_value _outv;
15329 
15330  {
15331  // Check if version >= 3.4.0
15332 # if OCTAVE_API_VERSION_NUMBER < 45
15333  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15334 # else
15335  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15336 # endif
15337  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15338  }
15339  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
15340  SWIG_fail;
15341  }
15342  plgver(arg1);
15343  _outv = octave_value();
15344  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15345  {
15346  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15347  }
15348 fail:
15349  return _out;
15350 }
15351 
15352 
15353 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
15354  PLFLT *arg1 = (PLFLT *) 0 ;
15355  PLFLT *arg2 = (PLFLT *) 0 ;
15356  PLFLT *arg3 = (PLFLT *) 0 ;
15357  PLFLT *arg4 = (PLFLT *) 0 ;
15358  PLFLT temp1 ;
15359  int res1 = SWIG_TMPOBJ ;
15360  PLFLT temp2 ;
15361  int res2 = SWIG_TMPOBJ ;
15362  PLFLT temp3 ;
15363  int res3 = SWIG_TMPOBJ ;
15364  PLFLT temp4 ;
15365  int res4 = SWIG_TMPOBJ ;
15366  octave_value_list _out;
15367  octave_value_list *_outp=&_out;
15368  octave_value _outv;
15369 
15370  arg1 = &temp1;
15371  arg2 = &temp2;
15372  arg3 = &temp3;
15373  arg4 = &temp4;
15374  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
15375  SWIG_fail;
15376  }
15377  plgvpd(arg1,arg2,arg3,arg4);
15378  _outv = octave_value();
15379  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15380  if (SWIG_IsTmpObj(res1)) {
15381  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15382  } else {
15383  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15384  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15385  }
15386  if (SWIG_IsTmpObj(res2)) {
15387  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15388  } else {
15389  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15390  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15391  }
15392  if (SWIG_IsTmpObj(res3)) {
15393  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15394  } else {
15395  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15396  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15397  }
15398  if (SWIG_IsTmpObj(res4)) {
15399  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15400  } else {
15401  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15402  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15403  }
15404 fail:
15405  return _out;
15406 }
15407 
15408 
15409 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
15410  PLFLT *arg1 = (PLFLT *) 0 ;
15411  PLFLT *arg2 = (PLFLT *) 0 ;
15412  PLFLT *arg3 = (PLFLT *) 0 ;
15413  PLFLT *arg4 = (PLFLT *) 0 ;
15414  PLFLT temp1 ;
15415  int res1 = SWIG_TMPOBJ ;
15416  PLFLT temp2 ;
15417  int res2 = SWIG_TMPOBJ ;
15418  PLFLT temp3 ;
15419  int res3 = SWIG_TMPOBJ ;
15420  PLFLT temp4 ;
15421  int res4 = SWIG_TMPOBJ ;
15422  octave_value_list _out;
15423  octave_value_list *_outp=&_out;
15424  octave_value _outv;
15425 
15426  arg1 = &temp1;
15427  arg2 = &temp2;
15428  arg3 = &temp3;
15429  arg4 = &temp4;
15430  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
15431  SWIG_fail;
15432  }
15433  plgvpw(arg1,arg2,arg3,arg4);
15434  _outv = octave_value();
15435  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15436  if (SWIG_IsTmpObj(res1)) {
15437  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15438  } else {
15439  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15440  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15441  }
15442  if (SWIG_IsTmpObj(res2)) {
15443  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15444  } else {
15445  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15446  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15447  }
15448  if (SWIG_IsTmpObj(res3)) {
15449  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15450  } else {
15451  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15452  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15453  }
15454  if (SWIG_IsTmpObj(res4)) {
15455  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15456  } else {
15457  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15458  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15459  }
15460 fail:
15461  return _out;
15462 }
15463 
15464 
15465 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
15466  PLINT *arg1 = (PLINT *) 0 ;
15467  PLINT *arg2 = (PLINT *) 0 ;
15468  PLINT temp1 ;
15469  int res1 = SWIG_TMPOBJ ;
15470  PLINT temp2 ;
15471  int res2 = SWIG_TMPOBJ ;
15472  octave_value_list _out;
15473  octave_value_list *_outp=&_out;
15474  octave_value _outv;
15475 
15476  arg1 = &temp1;
15477  arg2 = &temp2;
15478  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
15479  SWIG_fail;
15480  }
15481  plgxax(arg1,arg2);
15482  _outv = octave_value();
15483  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15484  if (SWIG_IsTmpObj(res1)) {
15485  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15486  } else {
15487  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15488  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15489  }
15490  if (SWIG_IsTmpObj(res2)) {
15491  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15492  } else {
15493  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15494  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15495  }
15496 fail:
15497  return _out;
15498 }
15499 
15500 
15501 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
15502  PLINT *arg1 = (PLINT *) 0 ;
15503  PLINT *arg2 = (PLINT *) 0 ;
15504  PLINT temp1 ;
15505  int res1 = SWIG_TMPOBJ ;
15506  PLINT temp2 ;
15507  int res2 = SWIG_TMPOBJ ;
15508  octave_value_list _out;
15509  octave_value_list *_outp=&_out;
15510  octave_value _outv;
15511 
15512  arg1 = &temp1;
15513  arg2 = &temp2;
15514  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
15515  SWIG_fail;
15516  }
15517  plgyax(arg1,arg2);
15518  _outv = octave_value();
15519  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15520  if (SWIG_IsTmpObj(res1)) {
15521  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15522  } else {
15523  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15524  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15525  }
15526  if (SWIG_IsTmpObj(res2)) {
15527  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15528  } else {
15529  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15530  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15531  }
15532 fail:
15533  return _out;
15534 }
15535 
15536 
15537 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
15538  PLINT *arg1 = (PLINT *) 0 ;
15539  PLINT *arg2 = (PLINT *) 0 ;
15540  PLINT temp1 ;
15541  int res1 = SWIG_TMPOBJ ;
15542  PLINT temp2 ;
15543  int res2 = SWIG_TMPOBJ ;
15544  octave_value_list _out;
15545  octave_value_list *_outp=&_out;
15546  octave_value _outv;
15547 
15548  arg1 = &temp1;
15549  arg2 = &temp2;
15550  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
15551  SWIG_fail;
15552  }
15553  plgzax(arg1,arg2);
15554  _outv = octave_value();
15555  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15556  if (SWIG_IsTmpObj(res1)) {
15557  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15558  } else {
15559  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15560  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15561  }
15562  if (SWIG_IsTmpObj(res2)) {
15563  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15564  } else {
15565  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15566  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15567  }
15568 fail:
15569  return _out;
15570 }
15571 
15572 
15573 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
15574  PLINT arg1 ;
15575  PLFLT *arg2 = (PLFLT *) 0 ;
15576  PLFLT arg3 ;
15577  PLFLT arg4 ;
15578  PLINT arg5 ;
15579  PLINT arg6 ;
15580  Matrix temp1 ;
15581  double val3 ;
15582  int ecode3 = 0 ;
15583  double val4 ;
15584  int ecode4 = 0 ;
15585  int val5 ;
15586  int ecode5 = 0 ;
15587  int val6 ;
15588  int ecode6 = 0 ;
15589  octave_value_list _out;
15590  octave_value_list *_outp=&_out;
15591  octave_value _outv;
15592 
15593  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
15594  SWIG_fail;
15595  }
15596  {
15597  if ( _n_dims( args(0) ) > 1 )
15598  {
15599  error( "argument must be a scalar or vector" ); SWIG_fail;
15600  }
15601  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
15602  temp1 = args(0).matrix_value();
15603  arg2 = &temp1( 0, 0 );
15604  }
15605  ecode3 = SWIG_AsVal_double(args(1), &val3);
15606  if (!SWIG_IsOK(ecode3)) {
15607  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
15608  }
15609  arg3 = (PLFLT)(val3);
15610  ecode4 = SWIG_AsVal_double(args(2), &val4);
15611  if (!SWIG_IsOK(ecode4)) {
15612  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
15613  }
15614  arg4 = (PLFLT)(val4);
15615  ecode5 = SWIG_AsVal_int(args(3), &val5);
15616  if (!SWIG_IsOK(ecode5)) {
15617  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
15618  }
15619  arg5 = (PLINT)(val5);
15620  ecode6 = SWIG_AsVal_int(args(4), &val6);
15621  if (!SWIG_IsOK(ecode6)) {
15622  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
15623  }
15624  arg6 = (PLINT)(val6);
15625  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
15626  _outv = octave_value();
15627  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15628  {
15629 
15630  }
15631 fail:
15632  return _out;
15633 }
15634 
15635 
15636 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
15637  PLFLT arg1 ;
15638  PLFLT arg2 ;
15639  PLFLT arg3 ;
15640  PLFLT *arg4 = (PLFLT *) 0 ;
15641  PLFLT *arg5 = (PLFLT *) 0 ;
15642  PLFLT *arg6 = (PLFLT *) 0 ;
15643  double val1 ;
15644  int ecode1 = 0 ;
15645  double val2 ;
15646  int ecode2 = 0 ;
15647  double val3 ;
15648  int ecode3 = 0 ;
15649  PLFLT temp4 ;
15650  int res4 = SWIG_TMPOBJ ;
15651  PLFLT temp5 ;
15652  int res5 = SWIG_TMPOBJ ;
15653  PLFLT temp6 ;
15654  int res6 = SWIG_TMPOBJ ;
15655  octave_value_list _out;
15656  octave_value_list *_outp=&_out;
15657  octave_value _outv;
15658 
15659  arg4 = &temp4;
15660  arg5 = &temp5;
15661  arg6 = &temp6;
15662  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
15663  SWIG_fail;
15664  }
15665  ecode1 = SWIG_AsVal_double(args(0), &val1);
15666  if (!SWIG_IsOK(ecode1)) {
15667  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
15668  }
15669  arg1 = (PLFLT)(val1);
15670  ecode2 = SWIG_AsVal_double(args(1), &val2);
15671  if (!SWIG_IsOK(ecode2)) {
15672  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
15673  }
15674  arg2 = (PLFLT)(val2);
15675  ecode3 = SWIG_AsVal_double(args(2), &val3);
15676  if (!SWIG_IsOK(ecode3)) {
15677  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
15678  }
15679  arg3 = (PLFLT)(val3);
15680  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
15681  _outv = octave_value();
15682  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15683  if (SWIG_IsTmpObj(res4)) {
15684  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15685  } else {
15686  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15687  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15688  }
15689  if (SWIG_IsTmpObj(res5)) {
15690  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
15691  } else {
15692  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15693  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15694  }
15695  if (SWIG_IsTmpObj(res6)) {
15696  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
15697  } else {
15698  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15699  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
15700  }
15701 fail:
15702  return _out;
15703 }
15704 
15705 
15706 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
15707  octave_value_list _out;
15708  octave_value_list *_outp=&_out;
15709  octave_value _outv;
15710 
15711  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
15712  SWIG_fail;
15713  }
15714  plinit();
15715  _outv = octave_value();
15716  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15717 fail:
15718  return _out;
15719 }
15720 
15721 
15722 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
15723  PLFLT arg1 ;
15724  PLFLT arg2 ;
15725  PLFLT arg3 ;
15726  PLFLT arg4 ;
15727  double val1 ;
15728  int ecode1 = 0 ;
15729  double val2 ;
15730  int ecode2 = 0 ;
15731  double val3 ;
15732  int ecode3 = 0 ;
15733  double val4 ;
15734  int ecode4 = 0 ;
15735  octave_value_list _out;
15736  octave_value_list *_outp=&_out;
15737  octave_value _outv;
15738 
15739  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
15740  SWIG_fail;
15741  }
15742  ecode1 = SWIG_AsVal_double(args(0), &val1);
15743  if (!SWIG_IsOK(ecode1)) {
15744  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
15745  }
15746  arg1 = (PLFLT)(val1);
15747  ecode2 = SWIG_AsVal_double(args(1), &val2);
15748  if (!SWIG_IsOK(ecode2)) {
15749  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
15750  }
15751  arg2 = (PLFLT)(val2);
15752  ecode3 = SWIG_AsVal_double(args(2), &val3);
15753  if (!SWIG_IsOK(ecode3)) {
15754  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
15755  }
15756  arg3 = (PLFLT)(val3);
15757  ecode4 = SWIG_AsVal_double(args(3), &val4);
15758  if (!SWIG_IsOK(ecode4)) {
15759  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
15760  }
15761  arg4 = (PLFLT)(val4);
15762  pljoin(arg1,arg2,arg3,arg4);
15763  _outv = octave_value();
15764  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15765 fail:
15766  return _out;
15767 }
15768 
15769 
15770 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
15771  char *arg1 = (char *) 0 ;
15772  char *arg2 = (char *) 0 ;
15773  char *arg3 = (char *) 0 ;
15774  int res1 ;
15775  char *buf1 = 0 ;
15776  int alloc1 = 0 ;
15777  int res2 ;
15778  char *buf2 = 0 ;
15779  int alloc2 = 0 ;
15780  int res3 ;
15781  char *buf3 = 0 ;
15782  int alloc3 = 0 ;
15783  octave_value_list _out;
15784  octave_value_list *_outp=&_out;
15785  octave_value _outv;
15786 
15787  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
15788  SWIG_fail;
15789  }
15790  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15791  if (!SWIG_IsOK(res1)) {
15792  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
15793  }
15794  arg1 = (char *)(buf1);
15795  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
15796  if (!SWIG_IsOK(res2)) {
15797  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
15798  }
15799  arg2 = (char *)(buf2);
15800  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
15801  if (!SWIG_IsOK(res3)) {
15802  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
15803  }
15804  arg3 = (char *)(buf3);
15805  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
15806  _outv = octave_value();
15807  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15808  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15809  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15810  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15811 fail:
15812  return _out;
15813 }
15814 
15815 
15816 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
15817  PLFLT *arg1 = (PLFLT *) 0 ;
15818  PLFLT *arg2 = (PLFLT *) 0 ;
15819  PLINT arg3 ;
15820  PLINT arg4 ;
15821  PLFLT arg5 ;
15822  PLFLT arg6 ;
15823  PLFLT arg7 ;
15824  PLINT arg8 ;
15825  PLINT arg9 ;
15826  PLINT arg10 ;
15827  PLINT arg11 ;
15828  PLINT arg12 ;
15829  PLINT arg13 ;
15830  PLINT *arg14 = (PLINT *) 0 ;
15831  PLFLT arg15 ;
15832  PLFLT arg16 ;
15833  PLFLT arg17 ;
15834  PLFLT arg18 ;
15835  PLINT *arg19 = (PLINT *) 0 ;
15836  char **arg20 = (char **) 0 ;
15837  PLINT *arg21 = (PLINT *) 0 ;
15838  PLINT *arg22 = (PLINT *) 0 ;
15839  PLFLT *arg23 = (PLFLT *) 0 ;
15840  PLFLT *arg24 = (PLFLT *) 0 ;
15841  PLINT *arg25 = (PLINT *) 0 ;
15842  PLINT *arg26 = (PLINT *) 0 ;
15843  PLFLT *arg27 = (PLFLT *) 0 ;
15844  PLINT *arg28 = (PLINT *) 0 ;
15845  PLFLT *arg29 = (PLFLT *) 0 ;
15846  PLINT *arg30 = (PLINT *) 0 ;
15847  char **arg31 = (char **) 0 ;
15848  PLFLT temp1 ;
15849  int res1 = SWIG_TMPOBJ ;
15850  PLFLT temp2 ;
15851  int res2 = SWIG_TMPOBJ ;
15852  int val3 ;
15853  int ecode3 = 0 ;
15854  int val4 ;
15855  int ecode4 = 0 ;
15856  double val5 ;
15857  int ecode5 = 0 ;
15858  double val6 ;
15859  int ecode6 = 0 ;
15860  double val7 ;
15861  int ecode7 = 0 ;
15862  int val8 ;
15863  int ecode8 = 0 ;
15864  int val9 ;
15865  int ecode9 = 0 ;
15866  int val10 ;
15867  int ecode10 = 0 ;
15868  int val11 ;
15869  int ecode11 = 0 ;
15870  int val12 ;
15871  int ecode12 = 0 ;
15872  Matrix temp13 ;
15873  double val15 ;
15874  int ecode15 = 0 ;
15875  double val16 ;
15876  int ecode16 = 0 ;
15877  double val17 ;
15878  int ecode17 = 0 ;
15879  double val18 ;
15880  int ecode18 = 0 ;
15881  Matrix temp19 ;
15882  Matrix temp21 ;
15883  Matrix temp22 ;
15884  Matrix temp23 ;
15885  Matrix temp24 ;
15886  Matrix temp25 ;
15887  Matrix temp26 ;
15888  Matrix temp27 ;
15889  Matrix temp28 ;
15890  Matrix temp29 ;
15891  Matrix temp30 ;
15892  octave_value_list _out;
15893  octave_value_list *_outp=&_out;
15894  octave_value _outv;
15895 
15896  arg1 = &temp1;
15897  arg2 = &temp2;
15898  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
15899  SWIG_fail;
15900  }
15901  ecode3 = SWIG_AsVal_int(args(0), &val3);
15902  if (!SWIG_IsOK(ecode3)) {
15903  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
15904  }
15905  arg3 = (PLINT)(val3);
15906  ecode4 = SWIG_AsVal_int(args(1), &val4);
15907  if (!SWIG_IsOK(ecode4)) {
15908  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
15909  }
15910  arg4 = (PLINT)(val4);
15911  ecode5 = SWIG_AsVal_double(args(2), &val5);
15912  if (!SWIG_IsOK(ecode5)) {
15913  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
15914  }
15915  arg5 = (PLFLT)(val5);
15916  ecode6 = SWIG_AsVal_double(args(3), &val6);
15917  if (!SWIG_IsOK(ecode6)) {
15918  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
15919  }
15920  arg6 = (PLFLT)(val6);
15921  ecode7 = SWIG_AsVal_double(args(4), &val7);
15922  if (!SWIG_IsOK(ecode7)) {
15923  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
15924  }
15925  arg7 = (PLFLT)(val7);
15926  ecode8 = SWIG_AsVal_int(args(5), &val8);
15927  if (!SWIG_IsOK(ecode8)) {
15928  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
15929  }
15930  arg8 = (PLINT)(val8);
15931  ecode9 = SWIG_AsVal_int(args(6), &val9);
15932  if (!SWIG_IsOK(ecode9)) {
15933  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
15934  }
15935  arg9 = (PLINT)(val9);
15936  ecode10 = SWIG_AsVal_int(args(7), &val10);
15937  if (!SWIG_IsOK(ecode10)) {
15938  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
15939  }
15940  arg10 = (PLINT)(val10);
15941  ecode11 = SWIG_AsVal_int(args(8), &val11);
15942  if (!SWIG_IsOK(ecode11)) {
15943  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
15944  }
15945  arg11 = (PLINT)(val11);
15946  ecode12 = SWIG_AsVal_int(args(9), &val12);
15947  if (!SWIG_IsOK(ecode12)) {
15948  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
15949  }
15950  arg12 = (PLINT)(val12);
15951  {
15952  if ( _n_dims( args(10) ) > 1 )
15953  {
15954  error( "argument must be a scalar or vector" ); SWIG_fail;
15955  }
15956  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
15957  arg14 = new PLINT[Alen];
15958  temp13 = args(10).matrix_value();
15959  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
15960  }
15961  ecode15 = SWIG_AsVal_double(args(11), &val15);
15962  if (!SWIG_IsOK(ecode15)) {
15963  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
15964  }
15965  arg15 = (PLFLT)(val15);
15966  ecode16 = SWIG_AsVal_double(args(12), &val16);
15967  if (!SWIG_IsOK(ecode16)) {
15968  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
15969  }
15970  arg16 = (PLFLT)(val16);
15971  ecode17 = SWIG_AsVal_double(args(13), &val17);
15972  if (!SWIG_IsOK(ecode17)) {
15973  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
15974  }
15975  arg17 = (PLFLT)(val17);
15976  ecode18 = SWIG_AsVal_double(args(14), &val18);
15977  if (!SWIG_IsOK(ecode18)) {
15978  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
15979  }
15980  arg18 = (PLFLT)(val18);
15981  {
15982  if ( _n_dims( args(15) ) > 1 )
15983  {
15984  error( "argument must be a scalar or vector" ); SWIG_fail;
15985  }
15986  if ( _dim( args(15), 0 ) != Alen )
15987  {
15988  error( "argument vectors must be same length" ); SWIG_fail;
15989  }
15990  temp19 = args(15).matrix_value();
15991  arg19 = new PLINT[Alen];
15992  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
15993  }
15994  {
15995  charMatrix temp_matrix;
15996  Cell temp_cell;
15997  char *tmp_cstring;
15998  std::string str;
15999  size_t max_length = 0, non_blank_length;
16000  int i, ifcell;
16001  if ( _n_dims( args(16) ) > 2 )
16002  {
16003  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16004  }
16005  if ( !args(16).is_empty() )
16006  {
16007  if ( _dim( args(16), 0 ) != Alen )
16008  {
16009  error( "first dimension must be same length as previous vector" ); SWIG_fail;
16010  }
16011  arg20 = new char*[Alen];
16012  ifcell = args(16).is_cell();
16013  if ( ifcell )
16014  {
16015  temp_cell = args(16).cell_value();
16016  }
16017  else
16018  {
16019  temp_matrix = args(16).char_matrix_value();
16020  // Allow one extra space for null termination.
16021  max_length = _dim( args(16), 1 ) + 1;
16022  }
16023 
16024  for ( i = 0; i < Alen; i++ )
16025  {
16026  // Must copy string to "permanent" location because the string
16027  // location corresponding to tmp_cstring gets
16028  // overwritten for each iteration of loop.
16029  if ( ifcell )
16030  {
16031  if ( temp_cell.elem( i ).is_string() )
16032  {
16033  str = temp_cell.elem( i ).string_value();
16034  // leave room for null termination.
16035  max_length = str.size() + 1;
16036  tmp_cstring = (char *) str.c_str();
16037  }
16038  else
16039  {
16040  // Use null string if user attempts to pass a cell array
16041  // with a non-string element (likely an empty element
16042  // since that should be allowed by the PLplot interface
16043  // if that element is going to be unused).
16044  // leave room for null termination.
16045  max_length = 1;
16046  tmp_cstring = (char *) "";
16047  }
16048  }
16049  else
16050  {
16051  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16052  }
16053  arg20[i] = new char[max_length];
16054  strncpy( arg20[i], tmp_cstring, max_length - 1 );
16055  arg20[i][max_length - 1] = '\0';
16056  // All the trailing blank crapola should not be needed for
16057  // string cell arrays.
16058  if ( !ifcell )
16059  {
16060  // remove trailing-blank padding that is used by the
16061  // charMatrix class to insure all strings in a given
16062  // charMatrix instance have the same length.
16063  // This transformation also removes legitimate trailing
16064  // blanks but there is nothing we can do about that
16065  // for the charMatrix class.
16066 
16067  // Look for trailing nulls first (just in case, although that
16068  // shouldn't happen if charMatrix implemented as documented)
16069  // before looking for trailing blanks.
16070  non_blank_length = max_length - 2;
16071  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16072  {
16073  non_blank_length--;
16074  }
16075  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16076  {
16077  non_blank_length--;
16078  }
16079  arg20[i][non_blank_length + 1] = '\0';
16080  }
16081  }
16082  }
16083  else
16084  {
16085  arg20 = NULL;
16086  }
16087  }
16088  {
16089  if ( _n_dims( args(17) ) > 1 )
16090  {
16091  error( "argument must be a scalar or vector" ); SWIG_fail;
16092  }
16093  if ( !args(17).is_empty() )
16094  {
16095  if ( _dim( args(17), 0 ) != Alen )
16096  {
16097  error( "argument vectors must be same length" ); SWIG_fail;
16098  }
16099  temp21 = args(17).matrix_value();
16100  arg21 = new PLINT[Alen];
16101  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
16102  }
16103  else
16104  {
16105  arg21 = NULL;
16106  }
16107  }
16108  {
16109  if ( _n_dims( args(18) ) > 1 )
16110  {
16111  error( "argument must be a scalar or vector" ); SWIG_fail;
16112  }
16113  if ( !args(18).is_empty() )
16114  {
16115  if ( _dim( args(18), 0 ) != Alen )
16116  {
16117  error( "argument vectors must be same length" ); SWIG_fail;
16118  }
16119  temp22 = args(18).matrix_value();
16120  arg22 = new PLINT[Alen];
16121  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16122  }
16123  else
16124  {
16125  arg22 = NULL;
16126  }
16127  }
16128  {
16129  if ( _n_dims( args(19) ) > 1 )
16130  {
16131  error( "argument must be a scalar or vector" ); SWIG_fail;
16132  }
16133  if ( !args(19).is_empty() )
16134  {
16135  if ( _dim( args(19), 0 ) != Alen )
16136  {
16137  error( "argument vectors must be same length" ); SWIG_fail;
16138  }
16139  temp23 = args(19).matrix_value();
16140  arg23 = &temp23( 0, 0 );
16141  }
16142  else
16143  {
16144  arg23 = NULL;
16145  }
16146  }
16147  {
16148  if ( _n_dims( args(20) ) > 1 )
16149  {
16150  error( "argument must be a scalar or vector" ); SWIG_fail;
16151  }
16152  if ( !args(20).is_empty() )
16153  {
16154  if ( _dim( args(20), 0 ) != Alen )
16155  {
16156  error( "argument vectors must be same length" ); SWIG_fail;
16157  }
16158  temp24 = args(20).matrix_value();
16159  arg24 = &temp24( 0, 0 );
16160  }
16161  else
16162  {
16163  arg24 = NULL;
16164  }
16165  }
16166  {
16167  if ( _n_dims( args(21) ) > 1 )
16168  {
16169  error( "argument must be a scalar or vector" ); SWIG_fail;
16170  }
16171  if ( !args(21).is_empty() )
16172  {
16173  if ( _dim( args(21), 0 ) != Alen )
16174  {
16175  error( "argument vectors must be same length" ); SWIG_fail;
16176  }
16177  temp25 = args(21).matrix_value();
16178  arg25 = new PLINT[Alen];
16179  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
16180  }
16181  else
16182  {
16183  arg25 = NULL;
16184  }
16185  }
16186  {
16187  if ( _n_dims( args(22) ) > 1 )
16188  {
16189  error( "argument must be a scalar or vector" ); SWIG_fail;
16190  }
16191  if ( !args(22).is_empty() )
16192  {
16193  if ( _dim( args(22), 0 ) != Alen )
16194  {
16195  error( "argument vectors must be same length" ); SWIG_fail;
16196  }
16197  temp26 = args(22).matrix_value();
16198  arg26 = new PLINT[Alen];
16199  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
16200  }
16201  else
16202  {
16203  arg26 = NULL;
16204  }
16205  }
16206  {
16207  if ( _n_dims( args(23) ) > 1 )
16208  {
16209  error( "argument must be a scalar or vector" ); SWIG_fail;
16210  }
16211  if ( !args(23).is_empty() )
16212  {
16213  if ( _dim( args(23), 0 ) != Alen )
16214  {
16215  error( "argument vectors must be same length" ); SWIG_fail;
16216  }
16217  temp27 = args(23).matrix_value();
16218  arg27 = &temp27( 0, 0 );
16219  }
16220  else
16221  {
16222  arg27 = NULL;
16223  }
16224  }
16225  {
16226  if ( _n_dims( args(24) ) > 1 )
16227  {
16228  error( "argument must be a scalar or vector" ); SWIG_fail;
16229  }
16230  if ( !args(24).is_empty() )
16231  {
16232  if ( _dim( args(24), 0 ) != Alen )
16233  {
16234  error( "argument vectors must be same length" ); SWIG_fail;
16235  }
16236  temp28 = args(24).matrix_value();
16237  arg28 = new PLINT[Alen];
16238  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
16239  }
16240  else
16241  {
16242  arg28 = NULL;
16243  }
16244  }
16245  {
16246  if ( _n_dims( args(25) ) > 1 )
16247  {
16248  error( "argument must be a scalar or vector" ); SWIG_fail;
16249  }
16250  if ( !args(25).is_empty() )
16251  {
16252  if ( _dim( args(25), 0 ) != Alen )
16253  {
16254  error( "argument vectors must be same length" ); SWIG_fail;
16255  }
16256  temp29 = args(25).matrix_value();
16257  arg29 = &temp29( 0, 0 );
16258  }
16259  else
16260  {
16261  arg29 = NULL;
16262  }
16263  }
16264  {
16265  if ( _n_dims( args(26) ) > 1 )
16266  {
16267  error( "argument must be a scalar or vector" ); SWIG_fail;
16268  }
16269  if ( !args(26).is_empty() )
16270  {
16271  if ( _dim( args(26), 0 ) != Alen )
16272  {
16273  error( "argument vectors must be same length" ); SWIG_fail;
16274  }
16275  temp30 = args(26).matrix_value();
16276  arg30 = new PLINT[Alen];
16277  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
16278  }
16279  else
16280  {
16281  arg30 = NULL;
16282  }
16283  }
16284  {
16285  charMatrix temp_matrix;
16286  Cell temp_cell;
16287  char *tmp_cstring;
16288  std::string str;
16289  size_t max_length = 0, non_blank_length;
16290  int i, ifcell;
16291  if ( _n_dims( args(27) ) > 2 )
16292  {
16293  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16294  }
16295  if ( !args(27).is_empty() )
16296  {
16297  if ( _dim( args(27), 0 ) != Alen )
16298  {
16299  error( "first dimension must be same length as previous vector" ); SWIG_fail;
16300  }
16301  arg31 = new char*[Alen];
16302  ifcell = args(27).is_cell();
16303  if ( ifcell )
16304  {
16305  temp_cell = args(27).cell_value();
16306  }
16307  else
16308  {
16309  temp_matrix = args(27).char_matrix_value();
16310  // Allow one extra space for null termination.
16311  max_length = _dim( args(27), 1 ) + 1;
16312  }
16313 
16314  for ( i = 0; i < Alen; i++ )
16315  {
16316  // Must copy string to "permanent" location because the string
16317  // location corresponding to tmp_cstring gets
16318  // overwritten for each iteration of loop.
16319  if ( ifcell )
16320  {
16321  if ( temp_cell.elem( i ).is_string() )
16322  {
16323  str = temp_cell.elem( i ).string_value();
16324  // leave room for null termination.
16325  max_length = str.size() + 1;
16326  tmp_cstring = (char *) str.c_str();
16327  }
16328  else
16329  {
16330  // Use null string if user attempts to pass a cell array
16331  // with a non-string element (likely an empty element
16332  // since that should be allowed by the PLplot interface
16333  // if that element is going to be unused).
16334  // leave room for null termination.
16335  max_length = 1;
16336  tmp_cstring = (char *) "";
16337  }
16338  }
16339  else
16340  {
16341  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16342  }
16343  arg31[i] = new char[max_length];
16344  strncpy( arg31[i], tmp_cstring, max_length - 1 );
16345  arg31[i][max_length - 1] = '\0';
16346  // All the trailing blank crapola should not be needed for
16347  // string cell arrays.
16348  if ( !ifcell )
16349  {
16350  // remove trailing-blank padding that is used by the
16351  // charMatrix class to insure all strings in a given
16352  // charMatrix instance have the same length.
16353  // This transformation also removes legitimate trailing
16354  // blanks but there is nothing we can do about that
16355  // for the charMatrix class.
16356 
16357  // Look for trailing nulls first (just in case, although that
16358  // shouldn't happen if charMatrix implemented as documented)
16359  // before looking for trailing blanks.
16360  non_blank_length = max_length - 2;
16361  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
16362  {
16363  non_blank_length--;
16364  }
16365  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
16366  {
16367  non_blank_length--;
16368  }
16369  arg31[i][non_blank_length + 1] = '\0';
16370  }
16371  }
16372  }
16373  else
16374  {
16375  arg31 = NULL;
16376  }
16377  }
16378  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);
16379  _outv = octave_value();
16380  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16381  if (SWIG_IsTmpObj(res1)) {
16382  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16383  } else {
16384  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16385  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16386  }
16387  if (SWIG_IsTmpObj(res2)) {
16388  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16389  } else {
16390  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16391  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16392  }
16393  {
16394  delete [] arg14;
16395  }
16396  {
16397  delete [] arg19;
16398  }
16399  {
16400  int i;
16401  if ( arg20 != NULL )
16402  {
16403  for ( i = 0; i < Alen; i++ )
16404  {
16405  delete[] arg20[i];
16406  }
16407  delete[] arg20;
16408  }
16409  }
16410  {
16411  if ( arg21 != NULL )
16412  delete [] arg21;
16413  }
16414  {
16415  if ( arg22 != NULL )
16416  delete [] arg22;
16417  }
16418  {
16419 
16420  }
16421  {
16422 
16423  }
16424  {
16425  if ( arg25 != NULL )
16426  delete [] arg25;
16427  }
16428  {
16429  if ( arg26 != NULL )
16430  delete [] arg26;
16431  }
16432  {
16433 
16434  }
16435  {
16436  if ( arg28 != NULL )
16437  delete [] arg28;
16438  }
16439  {
16440 
16441  }
16442  {
16443  if ( arg30 != NULL )
16444  delete [] arg30;
16445  }
16446  {
16447  int i;
16448  if ( arg31 != NULL )
16449  {
16450  for ( i = 0; i < Alen; i++ )
16451  {
16452  delete[] arg31[i];
16453  }
16454  delete[] arg31;
16455  }
16456  }
16457 fail:
16458  return _out;
16459 }
16460 
16461 
16462 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
16463  PLFLT arg1 ;
16464  PLFLT arg2 ;
16465  PLFLT arg3 ;
16466  double val1 ;
16467  int ecode1 = 0 ;
16468  double val2 ;
16469  int ecode2 = 0 ;
16470  double val3 ;
16471  int ecode3 = 0 ;
16472  octave_value_list _out;
16473  octave_value_list *_outp=&_out;
16474  octave_value _outv;
16475 
16476  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
16477  SWIG_fail;
16478  }
16479  ecode1 = SWIG_AsVal_double(args(0), &val1);
16480  if (!SWIG_IsOK(ecode1)) {
16481  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
16482  }
16483  arg1 = (PLFLT)(val1);
16484  ecode2 = SWIG_AsVal_double(args(1), &val2);
16485  if (!SWIG_IsOK(ecode2)) {
16486  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
16487  }
16488  arg2 = (PLFLT)(val2);
16489  ecode3 = SWIG_AsVal_double(args(2), &val3);
16490  if (!SWIG_IsOK(ecode3)) {
16491  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
16492  }
16493  arg3 = (PLFLT)(val3);
16494  pllightsource(arg1,arg2,arg3);
16495  _outv = octave_value();
16496  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16497 fail:
16498  return _out;
16499 }
16500 
16501 
16502 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
16503  PLINT arg1 ;
16504  PLFLT *arg2 = (PLFLT *) 0 ;
16505  PLFLT *arg3 = (PLFLT *) 0 ;
16506  Matrix temp1 ;
16507  Matrix temp3 ;
16508  octave_value_list _out;
16509  octave_value_list *_outp=&_out;
16510  octave_value _outv;
16511 
16512  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
16513  SWIG_fail;
16514  }
16515  {
16516  if ( _n_dims( args(0) ) > 1 )
16517  {
16518  error( "argument must be a scalar or vector" ); SWIG_fail;
16519  }
16520  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16521  temp1 = args(0).matrix_value();
16522  arg2 = &temp1( 0, 0 );
16523  }
16524  {
16525  if ( _n_dims( args(1) ) > 1 )
16526  {
16527  error( "argument must be a scalar or vector" ); SWIG_fail;
16528  }
16529  if ( _dim( args(1), 0 ) != Alen )
16530  {
16531  error( "argument vectors must be same length" ); SWIG_fail;
16532  }
16533  temp3 = args(1).matrix_value();
16534  arg3 = &temp3( 0, 0 );
16535  }
16536  plline(arg1,(double const *)arg2,(double const *)arg3);
16537  _outv = octave_value();
16538  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16539  {
16540 
16541  }
16542  {
16543 
16544  }
16545 fail:
16546  return _out;
16547 }
16548 
16549 
16550 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
16551  PLINT arg1 ;
16552  PLFLT *arg2 = (PLFLT *) 0 ;
16553  PLFLT *arg3 = (PLFLT *) 0 ;
16554  PLFLT *arg4 = (PLFLT *) 0 ;
16555  Matrix temp1 ;
16556  Matrix temp3 ;
16557  Matrix temp4 ;
16558  octave_value_list _out;
16559  octave_value_list *_outp=&_out;
16560  octave_value _outv;
16561 
16562  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
16563  SWIG_fail;
16564  }
16565  {
16566  if ( _n_dims( args(0) ) > 1 )
16567  {
16568  error( "argument must be a scalar or vector" ); SWIG_fail;
16569  }
16570  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16571  temp1 = args(0).matrix_value();
16572  arg2 = &temp1( 0, 0 );
16573  }
16574  {
16575  if ( _n_dims( args(1) ) > 1 )
16576  {
16577  error( "argument must be a scalar or vector" ); SWIG_fail;
16578  }
16579  if ( _dim( args(1), 0 ) != Alen )
16580  {
16581  error( "argument vectors must be same length" ); SWIG_fail;
16582  }
16583  temp3 = args(1).matrix_value();
16584  arg3 = &temp3( 0, 0 );
16585  }
16586  {
16587  if ( _n_dims( args(2) ) > 1 )
16588  {
16589  error( "argument must be a scalar or vector" ); SWIG_fail;
16590  }
16591  if ( _dim( args(2), 0 ) != Alen )
16592  {
16593  error( "argument vectors must be same length" ); SWIG_fail;
16594  }
16595  temp4 = args(2).matrix_value();
16596  arg4 = &temp4( 0, 0 );
16597  }
16598  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16599  _outv = octave_value();
16600  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16601  {
16602 
16603  }
16604  {
16605 
16606  }
16607  {
16608 
16609  }
16610 fail:
16611  return _out;
16612 }
16613 
16614 
16615 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
16616  PLINT arg1 ;
16617  int val1 ;
16618  int ecode1 = 0 ;
16619  octave_value_list _out;
16620  octave_value_list *_outp=&_out;
16621  octave_value _outv;
16622 
16623  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
16624  SWIG_fail;
16625  }
16626  ecode1 = SWIG_AsVal_int(args(0), &val1);
16627  if (!SWIG_IsOK(ecode1)) {
16628  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
16629  }
16630  arg1 = (PLINT)(val1);
16631  pllsty(arg1);
16632  _outv = octave_value();
16633  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16634 fail:
16635  return _out;
16636 }
16637 
16638 
16639 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
16640  PLINT *arg1 = (PLINT *) 0 ;
16641  PLINT temp1 ;
16642  int res1 = SWIG_TMPOBJ ;
16643  octave_value_list _out;
16644  octave_value_list *_outp=&_out;
16645  octave_value _outv;
16646 
16647  arg1 = &temp1;
16648  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
16649  SWIG_fail;
16650  }
16651  plmkstrm(arg1);
16652  _outv = octave_value();
16653  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16654  if (SWIG_IsTmpObj(res1)) {
16655  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16656  } else {
16657  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16658  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16659  }
16660 fail:
16661  return _out;
16662 }
16663 
16664 
16665 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
16666  char *arg1 = (char *) 0 ;
16667  PLFLT arg2 ;
16668  PLFLT arg3 ;
16669  PLFLT arg4 ;
16670  char *arg5 = (char *) 0 ;
16671  int res1 ;
16672  char *buf1 = 0 ;
16673  int alloc1 = 0 ;
16674  double val2 ;
16675  int ecode2 = 0 ;
16676  double val3 ;
16677  int ecode3 = 0 ;
16678  double val4 ;
16679  int ecode4 = 0 ;
16680  int res5 ;
16681  char *buf5 = 0 ;
16682  int alloc5 = 0 ;
16683  octave_value_list _out;
16684  octave_value_list *_outp=&_out;
16685  octave_value _outv;
16686 
16687  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
16688  SWIG_fail;
16689  }
16690  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16691  if (!SWIG_IsOK(res1)) {
16692  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
16693  }
16694  arg1 = (char *)(buf1);
16695  ecode2 = SWIG_AsVal_double(args(1), &val2);
16696  if (!SWIG_IsOK(ecode2)) {
16697  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
16698  }
16699  arg2 = (PLFLT)(val2);
16700  ecode3 = SWIG_AsVal_double(args(2), &val3);
16701  if (!SWIG_IsOK(ecode3)) {
16702  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
16703  }
16704  arg3 = (PLFLT)(val3);
16705  ecode4 = SWIG_AsVal_double(args(3), &val4);
16706  if (!SWIG_IsOK(ecode4)) {
16707  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
16708  }
16709  arg4 = (PLFLT)(val4);
16710  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16711  if (!SWIG_IsOK(res5)) {
16712  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
16713  }
16714  arg5 = (char *)(buf5);
16715  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
16716  _outv = octave_value();
16717  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16718  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16719  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16720 fail:
16721  return _out;
16722 }
16723 
16724 
16725 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
16726  char *arg1 = (char *) 0 ;
16727  PLFLT arg2 ;
16728  PLFLT arg3 ;
16729  PLFLT arg4 ;
16730  char *arg5 = (char *) 0 ;
16731  int res1 ;
16732  char *buf1 = 0 ;
16733  int alloc1 = 0 ;
16734  double val2 ;
16735  int ecode2 = 0 ;
16736  double val3 ;
16737  int ecode3 = 0 ;
16738  double val4 ;
16739  int ecode4 = 0 ;
16740  int res5 ;
16741  char *buf5 = 0 ;
16742  int alloc5 = 0 ;
16743  octave_value_list _out;
16744  octave_value_list *_outp=&_out;
16745  octave_value _outv;
16746 
16747  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
16748  SWIG_fail;
16749  }
16750  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16751  if (!SWIG_IsOK(res1)) {
16752  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
16753  }
16754  arg1 = (char *)(buf1);
16755  ecode2 = SWIG_AsVal_double(args(1), &val2);
16756  if (!SWIG_IsOK(ecode2)) {
16757  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
16758  }
16759  arg2 = (PLFLT)(val2);
16760  ecode3 = SWIG_AsVal_double(args(2), &val3);
16761  if (!SWIG_IsOK(ecode3)) {
16762  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
16763  }
16764  arg3 = (PLFLT)(val3);
16765  ecode4 = SWIG_AsVal_double(args(3), &val4);
16766  if (!SWIG_IsOK(ecode4)) {
16767  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
16768  }
16769  arg4 = (PLFLT)(val4);
16770  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16771  if (!SWIG_IsOK(res5)) {
16772  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
16773  }
16774  arg5 = (char *)(buf5);
16775  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
16776  _outv = octave_value();
16777  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16778  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16779  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16780 fail:
16781  return _out;
16782 }
16783 
16784 
16785 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
16786  int *arg1 = (int *) 0 ;
16787  char **arg2 = (char **) 0 ;
16788  PLINT arg3 ;
16789  void *argp1 = 0 ;
16790  int res1 = 0 ;
16791  void *argp2 = 0 ;
16792  int res2 = 0 ;
16793  int val3 ;
16794  int ecode3 = 0 ;
16795  octave_value_list _out;
16796  octave_value_list *_outp=&_out;
16797  octave_value _outv;
16798  PLINT result;
16799 
16800  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
16801  SWIG_fail;
16802  }
16803  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
16804  if (!SWIG_IsOK(res1)) {
16805  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
16806  }
16807  arg1 = (int *)(argp1);
16808  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
16809  if (!SWIG_IsOK(res2)) {
16810  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char const **""'");
16811  }
16812  arg2 = (char **)(argp2);
16813  ecode3 = SWIG_AsVal_int(args(2), &val3);
16814  if (!SWIG_IsOK(ecode3)) {
16815  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
16816  }
16817  arg3 = (PLINT)(val3);
16818  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
16819  _outv = SWIG_From_int((int)(result));
16820  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16821 fail:
16822  return _out;
16823 }
16824 
16825 
16826 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
16827  PLINT arg1 ;
16828  PLINT *arg2 = (PLINT *) 0 ;
16829  PLINT *arg3 = (PLINT *) 0 ;
16830  Matrix temp1 ;
16831  Matrix temp3 ;
16832  octave_value_list _out;
16833  octave_value_list *_outp=&_out;
16834  octave_value _outv;
16835 
16836  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
16837  SWIG_fail;
16838  }
16839  {
16840  if ( _n_dims( args(0) ) > 1 )
16841  {
16842  error( "argument must be a scalar or vector" ); SWIG_fail;
16843  }
16844  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16845  arg2 = new PLINT[Alen];
16846  temp1 = args(0).matrix_value();
16847  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
16848  }
16849  {
16850  if ( _n_dims( args(1) ) > 1 )
16851  {
16852  error( "argument must be a scalar or vector" ); SWIG_fail;
16853  }
16854  if ( _dim( args(1), 0 ) != Alen )
16855  {
16856  error( "argument vectors must be same length" ); SWIG_fail;
16857  }
16858  temp3 = args(1).matrix_value();
16859  arg3 = new PLINT[Alen];
16860  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
16861  }
16862  plpat(arg1,(int const *)arg2,(int const *)arg3);
16863  _outv = octave_value();
16864  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16865  {
16866  delete [] arg2;
16867  }
16868  {
16869  delete [] arg3;
16870  }
16871 fail:
16872  return _out;
16873 }
16874 
16875 
16876 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
16877  PLINT arg1 ;
16878  PLFLT arg2 ;
16879  PLFLT arg3 ;
16880  PLFLT arg4 ;
16881  PLFLT arg5 ;
16882  int val1 ;
16883  int ecode1 = 0 ;
16884  double val2 ;
16885  int ecode2 = 0 ;
16886  double val3 ;
16887  int ecode3 = 0 ;
16888  double val4 ;
16889  int ecode4 = 0 ;
16890  double val5 ;
16891  int ecode5 = 0 ;
16892  octave_value_list _out;
16893  octave_value_list *_outp=&_out;
16894  octave_value _outv;
16895 
16896  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
16897  SWIG_fail;
16898  }
16899  ecode1 = SWIG_AsVal_int(args(0), &val1);
16900  if (!SWIG_IsOK(ecode1)) {
16901  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
16902  }
16903  arg1 = (PLINT)(val1);
16904  ecode2 = SWIG_AsVal_double(args(1), &val2);
16905  if (!SWIG_IsOK(ecode2)) {
16906  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
16907  }
16908  arg2 = (PLFLT)(val2);
16909  ecode3 = SWIG_AsVal_double(args(2), &val3);
16910  if (!SWIG_IsOK(ecode3)) {
16911  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
16912  }
16913  arg3 = (PLFLT)(val3);
16914  ecode4 = SWIG_AsVal_double(args(3), &val4);
16915  if (!SWIG_IsOK(ecode4)) {
16916  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
16917  }
16918  arg4 = (PLFLT)(val4);
16919  ecode5 = SWIG_AsVal_double(args(4), &val5);
16920  if (!SWIG_IsOK(ecode5)) {
16921  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
16922  }
16923  arg5 = (PLFLT)(val5);
16924  plpath(arg1,arg2,arg3,arg4,arg5);
16925  _outv = octave_value();
16926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16927 fail:
16928  return _out;
16929 }
16930 
16931 
16932 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
16933  PLINT arg1 ;
16934  PLFLT *arg2 = (PLFLT *) 0 ;
16935  PLFLT *arg3 = (PLFLT *) 0 ;
16936  PLINT arg4 ;
16937  Matrix temp1 ;
16938  Matrix temp3 ;
16939  int val4 ;
16940  int ecode4 = 0 ;
16941  octave_value_list _out;
16942  octave_value_list *_outp=&_out;
16943  octave_value _outv;
16944 
16945  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
16946  SWIG_fail;
16947  }
16948  {
16949  if ( _n_dims( args(0) ) > 1 )
16950  {
16951  error( "argument must be a scalar or vector" ); SWIG_fail;
16952  }
16953  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16954  temp1 = args(0).matrix_value();
16955  arg2 = &temp1( 0, 0 );
16956  }
16957  {
16958  if ( _n_dims( args(1) ) > 1 )
16959  {
16960  error( "argument must be a scalar or vector" ); SWIG_fail;
16961  }
16962  if ( _dim( args(1), 0 ) != Alen )
16963  {
16964  error( "argument vectors must be same length" ); SWIG_fail;
16965  }
16966  temp3 = args(1).matrix_value();
16967  arg3 = &temp3( 0, 0 );
16968  }
16969  ecode4 = SWIG_AsVal_int(args(2), &val4);
16970  if (!SWIG_IsOK(ecode4)) {
16971  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
16972  }
16973  arg4 = (PLINT)(val4);
16974  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16975  _outv = octave_value();
16976  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16977  {
16978 
16979  }
16980  {
16981 
16982  }
16983 fail:
16984  return _out;
16985 }
16986 
16987 
16988 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
16989  PLINT arg1 ;
16990  PLFLT *arg2 = (PLFLT *) 0 ;
16991  PLFLT *arg3 = (PLFLT *) 0 ;
16992  PLFLT *arg4 = (PLFLT *) 0 ;
16993  PLINT arg5 ;
16994  Matrix temp1 ;
16995  Matrix temp3 ;
16996  Matrix temp4 ;
16997  int val5 ;
16998  int ecode5 = 0 ;
16999  octave_value_list _out;
17000  octave_value_list *_outp=&_out;
17001  octave_value _outv;
17002 
17003  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
17004  SWIG_fail;
17005  }
17006  {
17007  if ( _n_dims( args(0) ) > 1 )
17008  {
17009  error( "argument must be a scalar or vector" ); SWIG_fail;
17010  }
17011  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17012  temp1 = args(0).matrix_value();
17013  arg2 = &temp1( 0, 0 );
17014  }
17015  {
17016  if ( _n_dims( args(1) ) > 1 )
17017  {
17018  error( "argument must be a scalar or vector" ); SWIG_fail;
17019  }
17020  if ( _dim( args(1), 0 ) != Alen )
17021  {
17022  error( "argument vectors must be same length" ); SWIG_fail;
17023  }
17024  temp3 = args(1).matrix_value();
17025  arg3 = &temp3( 0, 0 );
17026  }
17027  {
17028  if ( _n_dims( args(2) ) > 1 )
17029  {
17030  error( "argument must be a scalar or vector" ); SWIG_fail;
17031  }
17032  if ( _dim( args(2), 0 ) != Alen )
17033  {
17034  error( "argument vectors must be same length" ); SWIG_fail;
17035  }
17036  temp4 = args(2).matrix_value();
17037  arg4 = &temp4( 0, 0 );
17038  }
17039  ecode5 = SWIG_AsVal_int(args(3), &val5);
17040  if (!SWIG_IsOK(ecode5)) {
17041  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
17042  }
17043  arg5 = (PLINT)(val5);
17044  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
17045  _outv = octave_value();
17046  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17047  {
17048 
17049  }
17050  {
17051 
17052  }
17053  {
17054 
17055  }
17056 fail:
17057  return _out;
17058 }
17059 
17060 
17061 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
17062  PLINT arg1 ;
17063  PLFLT *arg2 = (PLFLT *) 0 ;
17064  PLFLT *arg3 = (PLFLT *) 0 ;
17065  PLFLT *arg4 = (PLFLT *) 0 ;
17066  PLBOOL *arg5 = (PLBOOL *) 0 ;
17067  PLBOOL arg6 ;
17068  Matrix temp1 ;
17069  Matrix temp3 ;
17070  Matrix temp4 ;
17071  Matrix temp5 ;
17072  int val6 ;
17073  int ecode6 = 0 ;
17074  octave_value_list _out;
17075  octave_value_list *_outp=&_out;
17076  octave_value _outv;
17077 
17078  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
17079  SWIG_fail;
17080  }
17081  {
17082  if ( _n_dims( args(0) ) > 1 )
17083  {
17084  error( "argument must be a scalar or vector" ); SWIG_fail;
17085  }
17086  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17087  temp1 = args(0).matrix_value();
17088  arg2 = &temp1( 0, 0 );
17089  }
17090  {
17091  if ( _n_dims( args(1) ) > 1 )
17092  {
17093  error( "argument must be a scalar or vector" ); SWIG_fail;
17094  }
17095  if ( _dim( args(1), 0 ) != Alen )
17096  {
17097  error( "argument vectors must be same length" ); SWIG_fail;
17098  }
17099  temp3 = args(1).matrix_value();
17100  arg3 = &temp3( 0, 0 );
17101  }
17102  {
17103  if ( _n_dims( args(2) ) > 1 )
17104  {
17105  error( "argument must be a scalar or vector" ); SWIG_fail;
17106  }
17107  if ( _dim( args(2), 0 ) != Alen )
17108  {
17109  error( "argument vectors must be same length" ); SWIG_fail;
17110  }
17111  temp4 = args(2).matrix_value();
17112  arg4 = &temp4( 0, 0 );
17113  }
17114  {
17115  if ( _n_dims( args(3) ) > 1 )
17116  {
17117  error( "argument must be a scalar or vector" ); SWIG_fail;
17118  }
17119  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
17120  {
17121  error( "argument vector must be same length or one less" ); SWIG_fail;
17122  }
17123  temp5 = args(3).matrix_value();
17124  arg5 = new PLINT[Alen];
17125  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
17126  }
17127  ecode6 = SWIG_AsVal_int(args(4), &val6);
17128  if (!SWIG_IsOK(ecode6)) {
17129  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
17130  }
17131  arg6 = (PLBOOL)(val6);
17132  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
17133  _outv = octave_value();
17134  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17135  {
17136 
17137  }
17138  {
17139 
17140  }
17141  {
17142 
17143  }
17144  {
17145  delete [] arg5;
17146  }
17147 fail:
17148  return _out;
17149 }
17150 
17151 
17152 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
17153  PLINT arg1 ;
17154  PLINT arg2 ;
17155  int val1 ;
17156  int ecode1 = 0 ;
17157  int val2 ;
17158  int ecode2 = 0 ;
17159  octave_value_list _out;
17160  octave_value_list *_outp=&_out;
17161  octave_value _outv;
17162 
17163  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
17164  SWIG_fail;
17165  }
17166  ecode1 = SWIG_AsVal_int(args(0), &val1);
17167  if (!SWIG_IsOK(ecode1)) {
17168  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
17169  }
17170  arg1 = (PLINT)(val1);
17171  ecode2 = SWIG_AsVal_int(args(1), &val2);
17172  if (!SWIG_IsOK(ecode2)) {
17173  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
17174  }
17175  arg2 = (PLINT)(val2);
17176  plprec(arg1,arg2);
17177  _outv = octave_value();
17178  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17179 fail:
17180  return _out;
17181 }
17182 
17183 
17184 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
17185  PLINT arg1 ;
17186  int val1 ;
17187  int ecode1 = 0 ;
17188  octave_value_list _out;
17189  octave_value_list *_outp=&_out;
17190  octave_value _outv;
17191 
17192  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
17193  SWIG_fail;
17194  }
17195  ecode1 = SWIG_AsVal_int(args(0), &val1);
17196  if (!SWIG_IsOK(ecode1)) {
17197  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
17198  }
17199  arg1 = (PLINT)(val1);
17200  plpsty(arg1);
17201  _outv = octave_value();
17202  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17203 fail:
17204  return _out;
17205 }
17206 
17207 
17208 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
17209  PLFLT arg1 ;
17210  PLFLT arg2 ;
17211  PLFLT arg3 ;
17212  PLFLT arg4 ;
17213  PLFLT arg5 ;
17214  char *arg6 = (char *) 0 ;
17215  double val1 ;
17216  int ecode1 = 0 ;
17217  double val2 ;
17218  int ecode2 = 0 ;
17219  double val3 ;
17220  int ecode3 = 0 ;
17221  double val4 ;
17222  int ecode4 = 0 ;
17223  double val5 ;
17224  int ecode5 = 0 ;
17225  int res6 ;
17226  char *buf6 = 0 ;
17227  int alloc6 = 0 ;
17228  octave_value_list _out;
17229  octave_value_list *_outp=&_out;
17230  octave_value _outv;
17231 
17232  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
17233  SWIG_fail;
17234  }
17235  ecode1 = SWIG_AsVal_double(args(0), &val1);
17236  if (!SWIG_IsOK(ecode1)) {
17237  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
17238  }
17239  arg1 = (PLFLT)(val1);
17240  ecode2 = SWIG_AsVal_double(args(1), &val2);
17241  if (!SWIG_IsOK(ecode2)) {
17242  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
17243  }
17244  arg2 = (PLFLT)(val2);
17245  ecode3 = SWIG_AsVal_double(args(2), &val3);
17246  if (!SWIG_IsOK(ecode3)) {
17247  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
17248  }
17249  arg3 = (PLFLT)(val3);
17250  ecode4 = SWIG_AsVal_double(args(3), &val4);
17251  if (!SWIG_IsOK(ecode4)) {
17252  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
17253  }
17254  arg4 = (PLFLT)(val4);
17255  ecode5 = SWIG_AsVal_double(args(4), &val5);
17256  if (!SWIG_IsOK(ecode5)) {
17257  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
17258  }
17259  arg5 = (PLFLT)(val5);
17260  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17261  if (!SWIG_IsOK(res6)) {
17262  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
17263  }
17264  arg6 = (char *)(buf6);
17265  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
17266  _outv = octave_value();
17267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17268  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17269 fail:
17270  return _out;
17271 }
17272 
17273 
17274 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
17275  PLFLT arg1 ;
17276  PLFLT arg2 ;
17277  PLFLT arg3 ;
17278  PLFLT arg4 ;
17279  PLFLT arg5 ;
17280  PLFLT arg6 ;
17281  PLFLT arg7 ;
17282  PLFLT arg8 ;
17283  PLFLT arg9 ;
17284  PLFLT arg10 ;
17285  char *arg11 = (char *) 0 ;
17286  double val1 ;
17287  int ecode1 = 0 ;
17288  double val2 ;
17289  int ecode2 = 0 ;
17290  double val3 ;
17291  int ecode3 = 0 ;
17292  double val4 ;
17293  int ecode4 = 0 ;
17294  double val5 ;
17295  int ecode5 = 0 ;
17296  double val6 ;
17297  int ecode6 = 0 ;
17298  double val7 ;
17299  int ecode7 = 0 ;
17300  double val8 ;
17301  int ecode8 = 0 ;
17302  double val9 ;
17303  int ecode9 = 0 ;
17304  double val10 ;
17305  int ecode10 = 0 ;
17306  int res11 ;
17307  char *buf11 = 0 ;
17308  int alloc11 = 0 ;
17309  octave_value_list _out;
17310  octave_value_list *_outp=&_out;
17311  octave_value _outv;
17312 
17313  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
17314  SWIG_fail;
17315  }
17316  ecode1 = SWIG_AsVal_double(args(0), &val1);
17317  if (!SWIG_IsOK(ecode1)) {
17318  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
17319  }
17320  arg1 = (PLFLT)(val1);
17321  ecode2 = SWIG_AsVal_double(args(1), &val2);
17322  if (!SWIG_IsOK(ecode2)) {
17323  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
17324  }
17325  arg2 = (PLFLT)(val2);
17326  ecode3 = SWIG_AsVal_double(args(2), &val3);
17327  if (!SWIG_IsOK(ecode3)) {
17328  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
17329  }
17330  arg3 = (PLFLT)(val3);
17331  ecode4 = SWIG_AsVal_double(args(3), &val4);
17332  if (!SWIG_IsOK(ecode4)) {
17333  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
17334  }
17335  arg4 = (PLFLT)(val4);
17336  ecode5 = SWIG_AsVal_double(args(4), &val5);
17337  if (!SWIG_IsOK(ecode5)) {
17338  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
17339  }
17340  arg5 = (PLFLT)(val5);
17341  ecode6 = SWIG_AsVal_double(args(5), &val6);
17342  if (!SWIG_IsOK(ecode6)) {
17343  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
17344  }
17345  arg6 = (PLFLT)(val6);
17346  ecode7 = SWIG_AsVal_double(args(6), &val7);
17347  if (!SWIG_IsOK(ecode7)) {
17348  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
17349  }
17350  arg7 = (PLFLT)(val7);
17351  ecode8 = SWIG_AsVal_double(args(7), &val8);
17352  if (!SWIG_IsOK(ecode8)) {
17353  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
17354  }
17355  arg8 = (PLFLT)(val8);
17356  ecode9 = SWIG_AsVal_double(args(8), &val9);
17357  if (!SWIG_IsOK(ecode9)) {
17358  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
17359  }
17360  arg9 = (PLFLT)(val9);
17361  ecode10 = SWIG_AsVal_double(args(9), &val10);
17362  if (!SWIG_IsOK(ecode10)) {
17363  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
17364  }
17365  arg10 = (PLFLT)(val10);
17366  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
17367  if (!SWIG_IsOK(res11)) {
17368  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
17369  }
17370  arg11 = (char *)(buf11);
17371  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
17372  _outv = octave_value();
17373  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17374  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
17375 fail:
17376  return _out;
17377 }
17378 
17379 
17380 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
17381  octave_value_list _out;
17382  octave_value_list *_outp=&_out;
17383  octave_value _outv;
17384  PLFLT result;
17385 
17386  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
17387  SWIG_fail;
17388  }
17389  result = (PLFLT)plrandd();
17390  _outv = SWIG_From_double((double)(result));
17391  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17392 fail:
17393  return _out;
17394 }
17395 
17396 
17397 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
17398  octave_value_list _out;
17399  octave_value_list *_outp=&_out;
17400  octave_value _outv;
17401 
17402  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
17403  SWIG_fail;
17404  }
17405  plreplot();
17406  _outv = octave_value();
17407  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17408 fail:
17409  return _out;
17410 }
17411 
17412 
17413 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
17414  PLFLT arg1 ;
17415  PLFLT arg2 ;
17416  PLFLT arg3 ;
17417  PLFLT *arg4 = (PLFLT *) 0 ;
17418  PLFLT *arg5 = (PLFLT *) 0 ;
17419  PLFLT *arg6 = (PLFLT *) 0 ;
17420  double val1 ;
17421  int ecode1 = 0 ;
17422  double val2 ;
17423  int ecode2 = 0 ;
17424  double val3 ;
17425  int ecode3 = 0 ;
17426  PLFLT temp4 ;
17427  int res4 = SWIG_TMPOBJ ;
17428  PLFLT temp5 ;
17429  int res5 = SWIG_TMPOBJ ;
17430  PLFLT temp6 ;
17431  int res6 = SWIG_TMPOBJ ;
17432  octave_value_list _out;
17433  octave_value_list *_outp=&_out;
17434  octave_value _outv;
17435 
17436  arg4 = &temp4;
17437  arg5 = &temp5;
17438  arg6 = &temp6;
17439  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
17440  SWIG_fail;
17441  }
17442  ecode1 = SWIG_AsVal_double(args(0), &val1);
17443  if (!SWIG_IsOK(ecode1)) {
17444  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
17445  }
17446  arg1 = (PLFLT)(val1);
17447  ecode2 = SWIG_AsVal_double(args(1), &val2);
17448  if (!SWIG_IsOK(ecode2)) {
17449  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
17450  }
17451  arg2 = (PLFLT)(val2);
17452  ecode3 = SWIG_AsVal_double(args(2), &val3);
17453  if (!SWIG_IsOK(ecode3)) {
17454  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
17455  }
17456  arg3 = (PLFLT)(val3);
17457  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
17458  _outv = octave_value();
17459  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17460  if (SWIG_IsTmpObj(res4)) {
17461  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17462  } else {
17463  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17464  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17465  }
17466  if (SWIG_IsTmpObj(res5)) {
17467  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17468  } else {
17469  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17470  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17471  }
17472  if (SWIG_IsTmpObj(res6)) {
17473  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17474  } else {
17475  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17476  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17477  }
17478 fail:
17479  return _out;
17480 }
17481 
17482 
17483 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
17484  PLFLT arg1 ;
17485  PLFLT arg2 ;
17486  double val1 ;
17487  int ecode1 = 0 ;
17488  double val2 ;
17489  int ecode2 = 0 ;
17490  octave_value_list _out;
17491  octave_value_list *_outp=&_out;
17492  octave_value _outv;
17493 
17494  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
17495  SWIG_fail;
17496  }
17497  ecode1 = SWIG_AsVal_double(args(0), &val1);
17498  if (!SWIG_IsOK(ecode1)) {
17499  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
17500  }
17501  arg1 = (PLFLT)(val1);
17502  ecode2 = SWIG_AsVal_double(args(1), &val2);
17503  if (!SWIG_IsOK(ecode2)) {
17504  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
17505  }
17506  arg2 = (PLFLT)(val2);
17507  plschr(arg1,arg2);
17508  _outv = octave_value();
17509  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17510 fail:
17511  return _out;
17512 }
17513 
17514 
17515 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
17516  PLINT *arg1 = (PLINT *) 0 ;
17517  PLINT *arg2 = (PLINT *) 0 ;
17518  PLINT *arg3 = (PLINT *) 0 ;
17519  PLINT arg4 ;
17520  Matrix temp1 ;
17521  Matrix temp2 ;
17522  Matrix temp3 ;
17523  octave_value_list _out;
17524  octave_value_list *_outp=&_out;
17525  octave_value _outv;
17526 
17527  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
17528  SWIG_fail;
17529  }
17530  {
17531  if ( _n_dims( args(0) ) > 1 )
17532  {
17533  error( "argument must be a scalar or vector" ); SWIG_fail;
17534  }
17535  Alen = (PLINT) ( _dim( args(0), 0 ) );
17536  temp1 = args(0).matrix_value();
17537  arg1 = new PLINT[Alen];
17538  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17539  }
17540  {
17541  if ( _n_dims( args(1) ) > 1 )
17542  {
17543  error( "argument must be a scalar or vector" ); SWIG_fail;
17544  }
17545  if ( _dim( args(1), 0 ) != Alen )
17546  {
17547  error( "argument vectors must be same length" ); SWIG_fail;
17548  }
17549  temp2 = args(1).matrix_value();
17550  arg2 = new PLINT[Alen];
17551  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17552  }
17553  {
17554  if ( _n_dims( args(2) ) > 1 )
17555  {
17556  error( "argument must be a scalar or vector" ); SWIG_fail;
17557  }
17558  if ( _dim( args(2), 0 ) != Alen )
17559  {
17560  error( "argument vectors must be same length" ); SWIG_fail;
17561  }
17562  temp3 = args(2).matrix_value();
17563  arg3 = new PLINT[Alen];
17564  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17565  arg4 = Alen;
17566  }
17567  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
17568  _outv = octave_value();
17569  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17570  {
17571  delete [] arg1;
17572  }
17573  {
17574  delete [] arg2;
17575  }
17576  {
17577  delete [] arg3;
17578  }
17579 fail:
17580  return _out;
17581 }
17582 
17583 
17584 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
17585  PLINT *arg1 = (PLINT *) 0 ;
17586  PLINT *arg2 = (PLINT *) 0 ;
17587  PLINT *arg3 = (PLINT *) 0 ;
17588  PLFLT *arg4 = (PLFLT *) 0 ;
17589  PLINT arg5 ;
17590  Matrix temp1 ;
17591  Matrix temp2 ;
17592  Matrix temp3 ;
17593  Matrix temp4 ;
17594  octave_value_list _out;
17595  octave_value_list *_outp=&_out;
17596  octave_value _outv;
17597 
17598  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
17599  SWIG_fail;
17600  }
17601  {
17602  if ( _n_dims( args(0) ) > 1 )
17603  {
17604  error( "argument must be a scalar or vector" ); SWIG_fail;
17605  }
17606  Alen = (PLINT) ( _dim( args(0), 0 ) );
17607  temp1 = args(0).matrix_value();
17608  arg1 = new PLINT[Alen];
17609  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17610  }
17611  {
17612  if ( _n_dims( args(1) ) > 1 )
17613  {
17614  error( "argument must be a scalar or vector" ); SWIG_fail;
17615  }
17616  if ( _dim( args(1), 0 ) != Alen )
17617  {
17618  error( "argument vectors must be same length" ); SWIG_fail;
17619  }
17620  temp2 = args(1).matrix_value();
17621  arg2 = new PLINT[Alen];
17622  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17623  }
17624  {
17625  if ( _n_dims( args(2) ) > 1 )
17626  {
17627  error( "argument must be a scalar or vector" ); SWIG_fail;
17628  }
17629  if ( _dim( args(2), 0 ) != Alen )
17630  {
17631  error( "argument vectors must be same length" ); SWIG_fail;
17632  }
17633  temp3 = args(2).matrix_value();
17634  arg3 = new PLINT[Alen];
17635  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17636  }
17637  {
17638  if ( _n_dims( args(3) ) > 1 )
17639  {
17640  error( "argument must be a scalar or vector" ); SWIG_fail;
17641  }
17642  if ( _dim( args(3), 0 ) != Alen )
17643  {
17644  error( "argument vectors must be same length" ); SWIG_fail;
17645  }
17646  temp4 = args(3).matrix_value();
17647  arg4 = &temp4( 0, 0 );
17648  arg5 = (PLINT) ( _dim( args(3), 0 ) );
17649  }
17650  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
17651  _outv = octave_value();
17652  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17653  {
17654  delete [] arg1;
17655  }
17656  {
17657  delete [] arg2;
17658  }
17659  {
17660  delete [] arg3;
17661  }
17662  {
17663 
17664  }
17665 fail:
17666  return _out;
17667 }
17668 
17669 
17670 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
17671  PLINT arg1 ;
17672  int val1 ;
17673  int ecode1 = 0 ;
17674  octave_value_list _out;
17675  octave_value_list *_outp=&_out;
17676  octave_value _outv;
17677 
17678  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
17679  SWIG_fail;
17680  }
17681  ecode1 = SWIG_AsVal_int(args(0), &val1);
17682  if (!SWIG_IsOK(ecode1)) {
17683  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
17684  }
17685  arg1 = (PLINT)(val1);
17686  plscmap0n(arg1);
17687  _outv = octave_value();
17688  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17689 fail:
17690  return _out;
17691 }
17692 
17693 
17694 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
17695  PLINT *arg1 = (PLINT *) 0 ;
17696  PLINT *arg2 = (PLINT *) 0 ;
17697  PLINT *arg3 = (PLINT *) 0 ;
17698  PLINT arg4 ;
17699  Matrix temp1 ;
17700  Matrix temp2 ;
17701  Matrix temp3 ;
17702  octave_value_list _out;
17703  octave_value_list *_outp=&_out;
17704  octave_value _outv;
17705 
17706  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
17707  SWIG_fail;
17708  }
17709  {
17710  if ( _n_dims( args(0) ) > 1 )
17711  {
17712  error( "argument must be a scalar or vector" ); SWIG_fail;
17713  }
17714  Alen = (PLINT) ( _dim( args(0), 0 ) );
17715  temp1 = args(0).matrix_value();
17716  arg1 = new PLINT[Alen];
17717  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17718  }
17719  {
17720  if ( _n_dims( args(1) ) > 1 )
17721  {
17722  error( "argument must be a scalar or vector" ); SWIG_fail;
17723  }
17724  if ( _dim( args(1), 0 ) != Alen )
17725  {
17726  error( "argument vectors must be same length" ); SWIG_fail;
17727  }
17728  temp2 = args(1).matrix_value();
17729  arg2 = new PLINT[Alen];
17730  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17731  }
17732  {
17733  if ( _n_dims( args(2) ) > 1 )
17734  {
17735  error( "argument must be a scalar or vector" ); SWIG_fail;
17736  }
17737  if ( _dim( args(2), 0 ) != Alen )
17738  {
17739  error( "argument vectors must be same length" ); SWIG_fail;
17740  }
17741  temp3 = args(2).matrix_value();
17742  arg3 = new PLINT[Alen];
17743  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17744  arg4 = Alen;
17745  }
17746  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
17747  _outv = octave_value();
17748  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17749  {
17750  delete [] arg1;
17751  }
17752  {
17753  delete [] arg2;
17754  }
17755  {
17756  delete [] arg3;
17757  }
17758 fail:
17759  return _out;
17760 }
17761 
17762 
17763 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
17764  PLINT *arg1 = (PLINT *) 0 ;
17765  PLINT *arg2 = (PLINT *) 0 ;
17766  PLINT *arg3 = (PLINT *) 0 ;
17767  PLFLT *arg4 = (PLFLT *) 0 ;
17768  PLINT arg5 ;
17769  Matrix temp1 ;
17770  Matrix temp2 ;
17771  Matrix temp3 ;
17772  Matrix temp4 ;
17773  octave_value_list _out;
17774  octave_value_list *_outp=&_out;
17775  octave_value _outv;
17776 
17777  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
17778  SWIG_fail;
17779  }
17780  {
17781  if ( _n_dims( args(0) ) > 1 )
17782  {
17783  error( "argument must be a scalar or vector" ); SWIG_fail;
17784  }
17785  Alen = (PLINT) ( _dim( args(0), 0 ) );
17786  temp1 = args(0).matrix_value();
17787  arg1 = new PLINT[Alen];
17788  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17789  }
17790  {
17791  if ( _n_dims( args(1) ) > 1 )
17792  {
17793  error( "argument must be a scalar or vector" ); SWIG_fail;
17794  }
17795  if ( _dim( args(1), 0 ) != Alen )
17796  {
17797  error( "argument vectors must be same length" ); SWIG_fail;
17798  }
17799  temp2 = args(1).matrix_value();
17800  arg2 = new PLINT[Alen];
17801  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17802  }
17803  {
17804  if ( _n_dims( args(2) ) > 1 )
17805  {
17806  error( "argument must be a scalar or vector" ); SWIG_fail;
17807  }
17808  if ( _dim( args(2), 0 ) != Alen )
17809  {
17810  error( "argument vectors must be same length" ); SWIG_fail;
17811  }
17812  temp3 = args(2).matrix_value();
17813  arg3 = new PLINT[Alen];
17814  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17815  }
17816  {
17817  if ( _n_dims( args(3) ) > 1 )
17818  {
17819  error( "argument must be a scalar or vector" ); SWIG_fail;
17820  }
17821  if ( _dim( args(3), 0 ) != Alen )
17822  {
17823  error( "argument vectors must be same length" ); SWIG_fail;
17824  }
17825  temp4 = args(3).matrix_value();
17826  arg4 = &temp4( 0, 0 );
17827  arg5 = (PLINT) ( _dim( args(3), 0 ) );
17828  }
17829  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
17830  _outv = octave_value();
17831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17832  {
17833  delete [] arg1;
17834  }
17835  {
17836  delete [] arg2;
17837  }
17838  {
17839  delete [] arg3;
17840  }
17841  {
17842 
17843  }
17844 fail:
17845  return _out;
17846 }
17847 
17848 
17849 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
17850  PLBOOL arg1 ;
17851  PLINT arg2 ;
17852  PLFLT *arg3 = (PLFLT *) 0 ;
17853  PLFLT *arg4 = (PLFLT *) 0 ;
17854  PLFLT *arg5 = (PLFLT *) 0 ;
17855  PLFLT *arg6 = (PLFLT *) 0 ;
17856  PLBOOL *arg7 = (PLBOOL *) 0 ;
17857  int val1 ;
17858  int ecode1 = 0 ;
17859  Matrix temp2 ;
17860  Matrix temp4 ;
17861  Matrix temp5 ;
17862  Matrix temp6 ;
17863  Matrix temp7 ;
17864  octave_value_list _out;
17865  octave_value_list *_outp=&_out;
17866  octave_value _outv;
17867 
17868  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
17869  SWIG_fail;
17870  }
17871  ecode1 = SWIG_AsVal_int(args(0), &val1);
17872  if (!SWIG_IsOK(ecode1)) {
17873  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
17874  }
17875  arg1 = (PLBOOL)(val1);
17876  {
17877  if ( _n_dims( args(1) ) > 1 )
17878  {
17879  error( "argument must be a scalar or vector" ); SWIG_fail;
17880  }
17881  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
17882  temp2 = args(1).matrix_value();
17883  arg3 = &temp2( 0, 0 );
17884  }
17885  {
17886  if ( _n_dims( args(2) ) > 1 )
17887  {
17888  error( "argument must be a scalar or vector" ); SWIG_fail;
17889  }
17890  if ( _dim( args(2), 0 ) != Alen )
17891  {
17892  error( "argument vectors must be same length" ); SWIG_fail;
17893  }
17894  temp4 = args(2).matrix_value();
17895  arg4 = &temp4( 0, 0 );
17896  }
17897  {
17898  if ( _n_dims( args(3) ) > 1 )
17899  {
17900  error( "argument must be a scalar or vector" ); SWIG_fail;
17901  }
17902  if ( _dim( args(3), 0 ) != Alen )
17903  {
17904  error( "argument vectors must be same length" ); SWIG_fail;
17905  }
17906  temp5 = args(3).matrix_value();
17907  arg5 = &temp5( 0, 0 );
17908  }
17909  {
17910  if ( _n_dims( args(4) ) > 1 )
17911  {
17912  error( "argument must be a scalar or vector" ); SWIG_fail;
17913  }
17914  if ( _dim( args(4), 0 ) != Alen )
17915  {
17916  error( "argument vectors must be same length" ); SWIG_fail;
17917  }
17918  temp6 = args(4).matrix_value();
17919  arg6 = &temp6( 0, 0 );
17920  }
17921  {
17922  if ( _n_dims( args(5) ) > 1 )
17923  {
17924  error( "argument must be a scalar or vector" ); SWIG_fail;
17925  }
17926  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
17927  {
17928  error( "argument vector must be same length or one less" ); SWIG_fail;
17929  }
17930  temp7 = args(5).matrix_value();
17931  arg7 = new PLINT[Alen];
17932  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
17933  }
17934  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
17935  _outv = octave_value();
17936  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17937  {
17938 
17939  }
17940  {
17941 
17942  }
17943  {
17944 
17945  }
17946  {
17947 
17948  }
17949  {
17950  delete [] arg7;
17951  }
17952 fail:
17953  return _out;
17954 }
17955 
17956 
17957 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
17958  PLBOOL arg1 ;
17959  PLINT arg2 ;
17960  PLFLT *arg3 = (PLFLT *) 0 ;
17961  PLFLT *arg4 = (PLFLT *) 0 ;
17962  PLFLT *arg5 = (PLFLT *) 0 ;
17963  PLFLT *arg6 = (PLFLT *) 0 ;
17964  PLFLT *arg7 = (PLFLT *) 0 ;
17965  PLBOOL *arg8 = (PLBOOL *) 0 ;
17966  int val1 ;
17967  int ecode1 = 0 ;
17968  Matrix temp2 ;
17969  Matrix temp4 ;
17970  Matrix temp5 ;
17971  Matrix temp6 ;
17972  Matrix temp7 ;
17973  Matrix temp8 ;
17974  octave_value_list _out;
17975  octave_value_list *_outp=&_out;
17976  octave_value _outv;
17977 
17978  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
17979  SWIG_fail;
17980  }
17981  ecode1 = SWIG_AsVal_int(args(0), &val1);
17982  if (!SWIG_IsOK(ecode1)) {
17983  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
17984  }
17985  arg1 = (PLBOOL)(val1);
17986  {
17987  if ( _n_dims( args(1) ) > 1 )
17988  {
17989  error( "argument must be a scalar or vector" ); SWIG_fail;
17990  }
17991  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
17992  temp2 = args(1).matrix_value();
17993  arg3 = &temp2( 0, 0 );
17994  }
17995  {
17996  if ( _n_dims( args(2) ) > 1 )
17997  {
17998  error( "argument must be a scalar or vector" ); SWIG_fail;
17999  }
18000  if ( _dim( args(2), 0 ) != Alen )
18001  {
18002  error( "argument vectors must be same length" ); SWIG_fail;
18003  }
18004  temp4 = args(2).matrix_value();
18005  arg4 = &temp4( 0, 0 );
18006  }
18007  {
18008  if ( _n_dims( args(3) ) > 1 )
18009  {
18010  error( "argument must be a scalar or vector" ); SWIG_fail;
18011  }
18012  if ( _dim( args(3), 0 ) != Alen )
18013  {
18014  error( "argument vectors must be same length" ); SWIG_fail;
18015  }
18016  temp5 = args(3).matrix_value();
18017  arg5 = &temp5( 0, 0 );
18018  }
18019  {
18020  if ( _n_dims( args(4) ) > 1 )
18021  {
18022  error( "argument must be a scalar or vector" ); SWIG_fail;
18023  }
18024  if ( _dim( args(4), 0 ) != Alen )
18025  {
18026  error( "argument vectors must be same length" ); SWIG_fail;
18027  }
18028  temp6 = args(4).matrix_value();
18029  arg6 = &temp6( 0, 0 );
18030  }
18031  {
18032  if ( _n_dims( args(5) ) > 1 )
18033  {
18034  error( "argument must be a scalar or vector" ); SWIG_fail;
18035  }
18036  if ( _dim( args(5), 0 ) != Alen )
18037  {
18038  error( "argument vectors must be same length" ); SWIG_fail;
18039  }
18040  temp7 = args(5).matrix_value();
18041  arg7 = &temp7( 0, 0 );
18042  }
18043  {
18044  if ( _n_dims( args(6) ) > 1 )
18045  {
18046  error( "argument must be a scalar or vector" ); SWIG_fail;
18047  }
18048  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
18049  {
18050  error( "argument vector must be same length or one less" ); SWIG_fail;
18051  }
18052  temp8 = args(6).matrix_value();
18053  arg8 = new PLINT[Alen];
18054  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
18055  }
18056  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
18057  _outv = octave_value();
18058  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18059  {
18060 
18061  }
18062  {
18063 
18064  }
18065  {
18066 
18067  }
18068  {
18069 
18070  }
18071  {
18072 
18073  }
18074  {
18075  delete [] arg8;
18076  }
18077 fail:
18078  return _out;
18079 }
18080 
18081 
18082 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
18083  PLINT arg1 ;
18084  int val1 ;
18085  int ecode1 = 0 ;
18086  octave_value_list _out;
18087  octave_value_list *_outp=&_out;
18088  octave_value _outv;
18089 
18090  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
18091  SWIG_fail;
18092  }
18093  ecode1 = SWIG_AsVal_int(args(0), &val1);
18094  if (!SWIG_IsOK(ecode1)) {
18095  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
18096  }
18097  arg1 = (PLINT)(val1);
18098  plscmap1n(arg1);
18099  _outv = octave_value();
18100  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18101 fail:
18102  return _out;
18103 }
18104 
18105 
18107  PLFLT arg1 ;
18108  PLFLT arg2 ;
18109  double val1 ;
18110  int ecode1 = 0 ;
18111  double val2 ;
18112  int ecode2 = 0 ;
18113  octave_value_list _out;
18114  octave_value_list *_outp=&_out;
18115  octave_value _outv;
18116 
18117  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
18118  SWIG_fail;
18119  }
18120  ecode1 = SWIG_AsVal_double(args(0), &val1);
18121  if (!SWIG_IsOK(ecode1)) {
18122  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
18123  }
18124  arg1 = (PLFLT)(val1);
18125  ecode2 = SWIG_AsVal_double(args(1), &val2);
18126  if (!SWIG_IsOK(ecode2)) {
18127  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
18128  }
18129  arg2 = (PLFLT)(val2);
18130  plscmap1_range(arg1,arg2);
18131  _outv = octave_value();
18132  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18133 fail:
18134  return _out;
18135 }
18136 
18137 
18139  PLFLT *arg1 = (PLFLT *) 0 ;
18140  PLFLT *arg2 = (PLFLT *) 0 ;
18141  PLFLT temp1 ;
18142  int res1 = SWIG_TMPOBJ ;
18143  PLFLT temp2 ;
18144  int res2 = SWIG_TMPOBJ ;
18145  octave_value_list _out;
18146  octave_value_list *_outp=&_out;
18147  octave_value _outv;
18148 
18149  arg1 = &temp1;
18150  arg2 = &temp2;
18151  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
18152  SWIG_fail;
18153  }
18154  plgcmap1_range(arg1,arg2);
18155  _outv = octave_value();
18156  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18157  if (SWIG_IsTmpObj(res1)) {
18158  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18159  } else {
18160  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18161  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18162  }
18163  if (SWIG_IsTmpObj(res2)) {
18164  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18165  } else {
18166  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18167  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18168  }
18169 fail:
18170  return _out;
18171 }
18172 
18173 
18174 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
18175  PLINT arg1 ;
18176  PLINT arg2 ;
18177  PLINT arg3 ;
18178  PLINT arg4 ;
18179  int val1 ;
18180  int ecode1 = 0 ;
18181  int val2 ;
18182  int ecode2 = 0 ;
18183  int val3 ;
18184  int ecode3 = 0 ;
18185  int val4 ;
18186  int ecode4 = 0 ;
18187  octave_value_list _out;
18188  octave_value_list *_outp=&_out;
18189  octave_value _outv;
18190 
18191  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
18192  SWIG_fail;
18193  }
18194  ecode1 = SWIG_AsVal_int(args(0), &val1);
18195  if (!SWIG_IsOK(ecode1)) {
18196  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
18197  }
18198  arg1 = (PLINT)(val1);
18199  ecode2 = SWIG_AsVal_int(args(1), &val2);
18200  if (!SWIG_IsOK(ecode2)) {
18201  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
18202  }
18203  arg2 = (PLINT)(val2);
18204  ecode3 = SWIG_AsVal_int(args(2), &val3);
18205  if (!SWIG_IsOK(ecode3)) {
18206  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
18207  }
18208  arg3 = (PLINT)(val3);
18209  ecode4 = SWIG_AsVal_int(args(3), &val4);
18210  if (!SWIG_IsOK(ecode4)) {
18211  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
18212  }
18213  arg4 = (PLINT)(val4);
18214  plscol0(arg1,arg2,arg3,arg4);
18215  _outv = octave_value();
18216  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18217 fail:
18218  return _out;
18219 }
18220 
18221 
18222 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
18223  PLINT arg1 ;
18224  PLINT arg2 ;
18225  PLINT arg3 ;
18226  PLINT arg4 ;
18227  PLFLT arg5 ;
18228  int val1 ;
18229  int ecode1 = 0 ;
18230  int val2 ;
18231  int ecode2 = 0 ;
18232  int val3 ;
18233  int ecode3 = 0 ;
18234  int val4 ;
18235  int ecode4 = 0 ;
18236  double val5 ;
18237  int ecode5 = 0 ;
18238  octave_value_list _out;
18239  octave_value_list *_outp=&_out;
18240  octave_value _outv;
18241 
18242  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
18243  SWIG_fail;
18244  }
18245  ecode1 = SWIG_AsVal_int(args(0), &val1);
18246  if (!SWIG_IsOK(ecode1)) {
18247  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
18248  }
18249  arg1 = (PLINT)(val1);
18250  ecode2 = SWIG_AsVal_int(args(1), &val2);
18251  if (!SWIG_IsOK(ecode2)) {
18252  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
18253  }
18254  arg2 = (PLINT)(val2);
18255  ecode3 = SWIG_AsVal_int(args(2), &val3);
18256  if (!SWIG_IsOK(ecode3)) {
18257  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
18258  }
18259  arg3 = (PLINT)(val3);
18260  ecode4 = SWIG_AsVal_int(args(3), &val4);
18261  if (!SWIG_IsOK(ecode4)) {
18262  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
18263  }
18264  arg4 = (PLINT)(val4);
18265  ecode5 = SWIG_AsVal_double(args(4), &val5);
18266  if (!SWIG_IsOK(ecode5)) {
18267  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
18268  }
18269  arg5 = (PLFLT)(val5);
18270  plscol0a(arg1,arg2,arg3,arg4,arg5);
18271  _outv = octave_value();
18272  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18273 fail:
18274  return _out;
18275 }
18276 
18277 
18278 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
18279  PLINT arg1 ;
18280  PLINT arg2 ;
18281  PLINT arg3 ;
18282  int val1 ;
18283  int ecode1 = 0 ;
18284  int val2 ;
18285  int ecode2 = 0 ;
18286  int val3 ;
18287  int ecode3 = 0 ;
18288  octave_value_list _out;
18289  octave_value_list *_outp=&_out;
18290  octave_value _outv;
18291 
18292  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
18293  SWIG_fail;
18294  }
18295  ecode1 = SWIG_AsVal_int(args(0), &val1);
18296  if (!SWIG_IsOK(ecode1)) {
18297  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
18298  }
18299  arg1 = (PLINT)(val1);
18300  ecode2 = SWIG_AsVal_int(args(1), &val2);
18301  if (!SWIG_IsOK(ecode2)) {
18302  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
18303  }
18304  arg2 = (PLINT)(val2);
18305  ecode3 = SWIG_AsVal_int(args(2), &val3);
18306  if (!SWIG_IsOK(ecode3)) {
18307  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
18308  }
18309  arg3 = (PLINT)(val3);
18310  plscolbg(arg1,arg2,arg3);
18311  _outv = octave_value();
18312  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18313 fail:
18314  return _out;
18315 }
18316 
18317 
18318 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
18319  PLINT arg1 ;
18320  PLINT arg2 ;
18321  PLINT arg3 ;
18322  PLFLT arg4 ;
18323  int val1 ;
18324  int ecode1 = 0 ;
18325  int val2 ;
18326  int ecode2 = 0 ;
18327  int val3 ;
18328  int ecode3 = 0 ;
18329  double val4 ;
18330  int ecode4 = 0 ;
18331  octave_value_list _out;
18332  octave_value_list *_outp=&_out;
18333  octave_value _outv;
18334 
18335  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
18336  SWIG_fail;
18337  }
18338  ecode1 = SWIG_AsVal_int(args(0), &val1);
18339  if (!SWIG_IsOK(ecode1)) {
18340  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
18341  }
18342  arg1 = (PLINT)(val1);
18343  ecode2 = SWIG_AsVal_int(args(1), &val2);
18344  if (!SWIG_IsOK(ecode2)) {
18345  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
18346  }
18347  arg2 = (PLINT)(val2);
18348  ecode3 = SWIG_AsVal_int(args(2), &val3);
18349  if (!SWIG_IsOK(ecode3)) {
18350  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
18351  }
18352  arg3 = (PLINT)(val3);
18353  ecode4 = SWIG_AsVal_double(args(3), &val4);
18354  if (!SWIG_IsOK(ecode4)) {
18355  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
18356  }
18357  arg4 = (PLFLT)(val4);
18358  plscolbga(arg1,arg2,arg3,arg4);
18359  _outv = octave_value();
18360  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18361 fail:
18362  return _out;
18363 }
18364 
18365 
18366 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
18367  PLINT arg1 ;
18368  int val1 ;
18369  int ecode1 = 0 ;
18370  octave_value_list _out;
18371  octave_value_list *_outp=&_out;
18372  octave_value _outv;
18373 
18374  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
18375  SWIG_fail;
18376  }
18377  ecode1 = SWIG_AsVal_int(args(0), &val1);
18378  if (!SWIG_IsOK(ecode1)) {
18379  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
18380  }
18381  arg1 = (PLINT)(val1);
18382  plscolor(arg1);
18383  _outv = octave_value();
18384  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18385 fail:
18386  return _out;
18387 }
18388 
18389 
18390 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
18391  PLINT arg1 ;
18392  int val1 ;
18393  int ecode1 = 0 ;
18394  octave_value_list _out;
18395  octave_value_list *_outp=&_out;
18396  octave_value _outv;
18397 
18398  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
18399  SWIG_fail;
18400  }
18401  ecode1 = SWIG_AsVal_int(args(0), &val1);
18402  if (!SWIG_IsOK(ecode1)) {
18403  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
18404  }
18405  arg1 = (PLINT)(val1);
18406  plscompression(arg1);
18407  _outv = octave_value();
18408  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18409 fail:
18410  return _out;
18411 }
18412 
18413 
18414 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
18415  char *arg1 = (char *) 0 ;
18416  int res1 ;
18417  char *buf1 = 0 ;
18418  int alloc1 = 0 ;
18419  octave_value_list _out;
18420  octave_value_list *_outp=&_out;
18421  octave_value _outv;
18422 
18423  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
18424  SWIG_fail;
18425  }
18426  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18427  if (!SWIG_IsOK(res1)) {
18428  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
18429  }
18430  arg1 = (char *)(buf1);
18431  plsdev((char const *)arg1);
18432  _outv = octave_value();
18433  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18434  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18435 fail:
18436  return _out;
18437 }
18438 
18439 
18440 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
18441  PLFLT arg1 ;
18442  PLFLT arg2 ;
18443  PLFLT arg3 ;
18444  PLFLT arg4 ;
18445  double val1 ;
18446  int ecode1 = 0 ;
18447  double val2 ;
18448  int ecode2 = 0 ;
18449  double val3 ;
18450  int ecode3 = 0 ;
18451  double val4 ;
18452  int ecode4 = 0 ;
18453  octave_value_list _out;
18454  octave_value_list *_outp=&_out;
18455  octave_value _outv;
18456 
18457  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
18458  SWIG_fail;
18459  }
18460  ecode1 = SWIG_AsVal_double(args(0), &val1);
18461  if (!SWIG_IsOK(ecode1)) {
18462  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
18463  }
18464  arg1 = (PLFLT)(val1);
18465  ecode2 = SWIG_AsVal_double(args(1), &val2);
18466  if (!SWIG_IsOK(ecode2)) {
18467  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
18468  }
18469  arg2 = (PLFLT)(val2);
18470  ecode3 = SWIG_AsVal_double(args(2), &val3);
18471  if (!SWIG_IsOK(ecode3)) {
18472  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
18473  }
18474  arg3 = (PLFLT)(val3);
18475  ecode4 = SWIG_AsVal_double(args(3), &val4);
18476  if (!SWIG_IsOK(ecode4)) {
18477  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
18478  }
18479  arg4 = (PLFLT)(val4);
18480  plsdidev(arg1,arg2,arg3,arg4);
18481  _outv = octave_value();
18482  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18483 fail:
18484  return _out;
18485 }
18486 
18487 
18488 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
18489  PLINT arg1 ;
18490  PLINT arg2 ;
18491  PLINT arg3 ;
18492  PLINT arg4 ;
18493  PLFLT arg5 ;
18494  PLFLT arg6 ;
18495  int val1 ;
18496  int ecode1 = 0 ;
18497  int val2 ;
18498  int ecode2 = 0 ;
18499  int val3 ;
18500  int ecode3 = 0 ;
18501  int val4 ;
18502  int ecode4 = 0 ;
18503  double val5 ;
18504  int ecode5 = 0 ;
18505  double val6 ;
18506  int ecode6 = 0 ;
18507  octave_value_list _out;
18508  octave_value_list *_outp=&_out;
18509  octave_value _outv;
18510 
18511  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
18512  SWIG_fail;
18513  }
18514  ecode1 = SWIG_AsVal_int(args(0), &val1);
18515  if (!SWIG_IsOK(ecode1)) {
18516  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
18517  }
18518  arg1 = (PLINT)(val1);
18519  ecode2 = SWIG_AsVal_int(args(1), &val2);
18520  if (!SWIG_IsOK(ecode2)) {
18521  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
18522  }
18523  arg2 = (PLINT)(val2);
18524  ecode3 = SWIG_AsVal_int(args(2), &val3);
18525  if (!SWIG_IsOK(ecode3)) {
18526  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
18527  }
18528  arg3 = (PLINT)(val3);
18529  ecode4 = SWIG_AsVal_int(args(3), &val4);
18530  if (!SWIG_IsOK(ecode4)) {
18531  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
18532  }
18533  arg4 = (PLINT)(val4);
18534  ecode5 = SWIG_AsVal_double(args(4), &val5);
18535  if (!SWIG_IsOK(ecode5)) {
18536  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
18537  }
18538  arg5 = (PLFLT)(val5);
18539  ecode6 = SWIG_AsVal_double(args(5), &val6);
18540  if (!SWIG_IsOK(ecode6)) {
18541  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
18542  }
18543  arg6 = (PLFLT)(val6);
18544  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
18545  _outv = octave_value();
18546  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18547 fail:
18548  return _out;
18549 }
18550 
18551 
18552 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
18553  PLFLT arg1 ;
18554  double val1 ;
18555  int ecode1 = 0 ;
18556  octave_value_list _out;
18557  octave_value_list *_outp=&_out;
18558  octave_value _outv;
18559 
18560  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
18561  SWIG_fail;
18562  }
18563  ecode1 = SWIG_AsVal_double(args(0), &val1);
18564  if (!SWIG_IsOK(ecode1)) {
18565  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
18566  }
18567  arg1 = (PLFLT)(val1);
18568  plsdiori(arg1);
18569  _outv = octave_value();
18570  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18571 fail:
18572  return _out;
18573 }
18574 
18575 
18576 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
18577  PLFLT arg1 ;
18578  PLFLT arg2 ;
18579  PLFLT arg3 ;
18580  PLFLT arg4 ;
18581  double val1 ;
18582  int ecode1 = 0 ;
18583  double val2 ;
18584  int ecode2 = 0 ;
18585  double val3 ;
18586  int ecode3 = 0 ;
18587  double val4 ;
18588  int ecode4 = 0 ;
18589  octave_value_list _out;
18590  octave_value_list *_outp=&_out;
18591  octave_value _outv;
18592 
18593  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
18594  SWIG_fail;
18595  }
18596  ecode1 = SWIG_AsVal_double(args(0), &val1);
18597  if (!SWIG_IsOK(ecode1)) {
18598  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
18599  }
18600  arg1 = (PLFLT)(val1);
18601  ecode2 = SWIG_AsVal_double(args(1), &val2);
18602  if (!SWIG_IsOK(ecode2)) {
18603  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
18604  }
18605  arg2 = (PLFLT)(val2);
18606  ecode3 = SWIG_AsVal_double(args(2), &val3);
18607  if (!SWIG_IsOK(ecode3)) {
18608  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
18609  }
18610  arg3 = (PLFLT)(val3);
18611  ecode4 = SWIG_AsVal_double(args(3), &val4);
18612  if (!SWIG_IsOK(ecode4)) {
18613  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
18614  }
18615  arg4 = (PLFLT)(val4);
18616  plsdiplt(arg1,arg2,arg3,arg4);
18617  _outv = octave_value();
18618  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18619 fail:
18620  return _out;
18621 }
18622 
18623 
18624 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
18625  PLFLT arg1 ;
18626  PLFLT arg2 ;
18627  PLFLT arg3 ;
18628  PLFLT arg4 ;
18629  double val1 ;
18630  int ecode1 = 0 ;
18631  double val2 ;
18632  int ecode2 = 0 ;
18633  double val3 ;
18634  int ecode3 = 0 ;
18635  double val4 ;
18636  int ecode4 = 0 ;
18637  octave_value_list _out;
18638  octave_value_list *_outp=&_out;
18639  octave_value _outv;
18640 
18641  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
18642  SWIG_fail;
18643  }
18644  ecode1 = SWIG_AsVal_double(args(0), &val1);
18645  if (!SWIG_IsOK(ecode1)) {
18646  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
18647  }
18648  arg1 = (PLFLT)(val1);
18649  ecode2 = SWIG_AsVal_double(args(1), &val2);
18650  if (!SWIG_IsOK(ecode2)) {
18651  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
18652  }
18653  arg2 = (PLFLT)(val2);
18654  ecode3 = SWIG_AsVal_double(args(2), &val3);
18655  if (!SWIG_IsOK(ecode3)) {
18656  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
18657  }
18658  arg3 = (PLFLT)(val3);
18659  ecode4 = SWIG_AsVal_double(args(3), &val4);
18660  if (!SWIG_IsOK(ecode4)) {
18661  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
18662  }
18663  arg4 = (PLFLT)(val4);
18664  plsdiplz(arg1,arg2,arg3,arg4);
18665  _outv = octave_value();
18666  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18667 fail:
18668  return _out;
18669 }
18670 
18671 
18672 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
18673  unsigned int arg1 ;
18674  unsigned int val1 ;
18675  int ecode1 = 0 ;
18676  octave_value_list _out;
18677  octave_value_list *_outp=&_out;
18678  octave_value _outv;
18679 
18680  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
18681  SWIG_fail;
18682  }
18683  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
18684  if (!SWIG_IsOK(ecode1)) {
18685  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
18686  }
18687  arg1 = (unsigned int)(val1);
18688  plseed(arg1);
18689  _outv = octave_value();
18690  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18691 fail:
18692  return _out;
18693 }
18694 
18695 
18696 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
18697  char arg1 ;
18698  char val1 ;
18699  int ecode1 = 0 ;
18700  octave_value_list _out;
18701  octave_value_list *_outp=&_out;
18702  octave_value _outv;
18703 
18704  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
18705  SWIG_fail;
18706  }
18707  ecode1 = SWIG_AsVal_char(args(0), &val1);
18708  if (!SWIG_IsOK(ecode1)) {
18709  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
18710  }
18711  arg1 = (char)(val1);
18712  plsesc(arg1);
18713  _outv = octave_value();
18714  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18715 fail:
18716  return _out;
18717 }
18718 
18719 
18720 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
18721  char *arg1 = (char *) 0 ;
18722  char *arg2 = (char *) 0 ;
18723  int res1 ;
18724  char *buf1 = 0 ;
18725  int alloc1 = 0 ;
18726  int res2 ;
18727  char *buf2 = 0 ;
18728  int alloc2 = 0 ;
18729  octave_value_list _out;
18730  octave_value_list *_outp=&_out;
18731  octave_value _outv;
18732  PLINT result;
18733 
18734  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
18735  SWIG_fail;
18736  }
18737  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18738  if (!SWIG_IsOK(res1)) {
18739  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
18740  }
18741  arg1 = (char *)(buf1);
18742  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
18743  if (!SWIG_IsOK(res2)) {
18744  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
18745  }
18746  arg2 = (char *)(buf2);
18747  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
18748  _outv = SWIG_From_int((int)(result));
18749  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18750  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18751  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18752 fail:
18753  return _out;
18754 }
18755 
18756 
18757 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
18758  PLINT arg1 ;
18759  PLINT arg2 ;
18760  PLINT arg3 ;
18761  int val1 ;
18762  int ecode1 = 0 ;
18763  int val2 ;
18764  int ecode2 = 0 ;
18765  int val3 ;
18766  int ecode3 = 0 ;
18767  octave_value_list _out;
18768  octave_value_list *_outp=&_out;
18769  octave_value _outv;
18770 
18771  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
18772  SWIG_fail;
18773  }
18774  ecode1 = SWIG_AsVal_int(args(0), &val1);
18775  if (!SWIG_IsOK(ecode1)) {
18776  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
18777  }
18778  arg1 = (PLINT)(val1);
18779  ecode2 = SWIG_AsVal_int(args(1), &val2);
18780  if (!SWIG_IsOK(ecode2)) {
18781  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
18782  }
18783  arg2 = (PLINT)(val2);
18784  ecode3 = SWIG_AsVal_int(args(2), &val3);
18785  if (!SWIG_IsOK(ecode3)) {
18786  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
18787  }
18788  arg3 = (PLINT)(val3);
18789  plsfam(arg1,arg2,arg3);
18790  _outv = octave_value();
18791  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18792 fail:
18793  return _out;
18794 }
18795 
18796 
18797 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
18798  PLUNICODE arg1 ;
18799  unsigned int val1 ;
18800  int ecode1 = 0 ;
18801  octave_value_list _out;
18802  octave_value_list *_outp=&_out;
18803  octave_value _outv;
18804 
18805  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
18806  SWIG_fail;
18807  }
18808  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
18809  if (!SWIG_IsOK(ecode1)) {
18810  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
18811  }
18812  arg1 = (PLUNICODE)(val1);
18813  plsfci(arg1);
18814  _outv = octave_value();
18815  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18816 fail:
18817  return _out;
18818 }
18819 
18820 
18821 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
18822  char *arg1 = (char *) 0 ;
18823  int res1 ;
18824  char *buf1 = 0 ;
18825  int alloc1 = 0 ;
18826  octave_value_list _out;
18827  octave_value_list *_outp=&_out;
18828  octave_value _outv;
18829 
18830  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
18831  SWIG_fail;
18832  }
18833  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18834  if (!SWIG_IsOK(res1)) {
18835  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
18836  }
18837  arg1 = (char *)(buf1);
18838  plsfnam((char const *)arg1);
18839  _outv = octave_value();
18840  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18841  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18842 fail:
18843  return _out;
18844 }
18845 
18846 
18847 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
18848  PLINT arg1 ;
18849  PLINT arg2 ;
18850  PLINT arg3 ;
18851  int val1 ;
18852  int ecode1 = 0 ;
18853  int val2 ;
18854  int ecode2 = 0 ;
18855  int val3 ;
18856  int ecode3 = 0 ;
18857  octave_value_list _out;
18858  octave_value_list *_outp=&_out;
18859  octave_value _outv;
18860 
18861  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
18862  SWIG_fail;
18863  }
18864  ecode1 = SWIG_AsVal_int(args(0), &val1);
18865  if (!SWIG_IsOK(ecode1)) {
18866  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
18867  }
18868  arg1 = (PLINT)(val1);
18869  ecode2 = SWIG_AsVal_int(args(1), &val2);
18870  if (!SWIG_IsOK(ecode2)) {
18871  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
18872  }
18873  arg2 = (PLINT)(val2);
18874  ecode3 = SWIG_AsVal_int(args(2), &val3);
18875  if (!SWIG_IsOK(ecode3)) {
18876  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
18877  }
18878  arg3 = (PLINT)(val3);
18879  plsfont(arg1,arg2,arg3);
18880  _outv = octave_value();
18881  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18882 fail:
18883  return _out;
18884 }
18885 
18886 
18887 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
18888  label_func arg1 = (label_func) 0 ;
18889  PLPointer arg2 = (PLPointer) 0 ;
18890  int res2 ;
18891  octave_value_list _out;
18892  octave_value_list *_outp=&_out;
18893  octave_value _outv;
18894 
18895  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
18896  SWIG_fail;
18897  }
18898  {
18899  octave_value obj = args(0);
18900  if ( !obj.is_empty() )
18901  {
18902  if ( obj.is_function_handle() || obj.is_inline_function() )
18903  {
18904  fcnLabelFunc = obj.function_value();
18905  }
18906  else if ( obj.is_string() )
18907  {
18908  nameLabelFunc = obj.string_value();
18909  fcnLabelFunc = NULL;
18910  }
18911  arg1 = labelfunc_octave;
18912  }
18913  else
18914  {
18915  arg1 = NULL;
18916  }
18917  }
18918  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
18919  if (!SWIG_IsOK(res2)) {
18920  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
18921  }
18922  plslabelfunc(arg1,arg2);
18923  _outv = octave_value();
18924  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18925 fail:
18926  return _out;
18927 }
18928 
18929 
18930 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
18931  PLFLT arg1 ;
18932  PLFLT arg2 ;
18933  double val1 ;
18934  int ecode1 = 0 ;
18935  double val2 ;
18936  int ecode2 = 0 ;
18937  octave_value_list _out;
18938  octave_value_list *_outp=&_out;
18939  octave_value _outv;
18940 
18941  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
18942  SWIG_fail;
18943  }
18944  ecode1 = SWIG_AsVal_double(args(0), &val1);
18945  if (!SWIG_IsOK(ecode1)) {
18946  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
18947  }
18948  arg1 = (PLFLT)(val1);
18949  ecode2 = SWIG_AsVal_double(args(1), &val2);
18950  if (!SWIG_IsOK(ecode2)) {
18951  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
18952  }
18953  arg2 = (PLFLT)(val2);
18954  plsmaj(arg1,arg2);
18955  _outv = octave_value();
18956  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18957 fail:
18958  return _out;
18959 }
18960 
18961 
18962 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
18963  PLFLT arg1 ;
18964  PLFLT arg2 ;
18965  double val1 ;
18966  int ecode1 = 0 ;
18967  double val2 ;
18968  int ecode2 = 0 ;
18969  octave_value_list _out;
18970  octave_value_list *_outp=&_out;
18971  octave_value _outv;
18972 
18973  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
18974  SWIG_fail;
18975  }
18976  ecode1 = SWIG_AsVal_double(args(0), &val1);
18977  if (!SWIG_IsOK(ecode1)) {
18978  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
18979  }
18980  arg1 = (PLFLT)(val1);
18981  ecode2 = SWIG_AsVal_double(args(1), &val2);
18982  if (!SWIG_IsOK(ecode2)) {
18983  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
18984  }
18985  arg2 = (PLFLT)(val2);
18986  plsmin(arg1,arg2);
18987  _outv = octave_value();
18988  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18989 fail:
18990  return _out;
18991 }
18992 
18993 
18994 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
18995  PLINT arg1 ;
18996  int val1 ;
18997  int ecode1 = 0 ;
18998  octave_value_list _out;
18999  octave_value_list *_outp=&_out;
19000  octave_value _outv;
19001 
19002  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
19003  SWIG_fail;
19004  }
19005  ecode1 = SWIG_AsVal_int(args(0), &val1);
19006  if (!SWIG_IsOK(ecode1)) {
19007  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
19008  }
19009  arg1 = (PLINT)(val1);
19010  plsori(arg1);
19011  _outv = octave_value();
19012  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19013 fail:
19014  return _out;
19015 }
19016 
19017 
19018 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
19019  PLFLT arg1 ;
19020  PLFLT arg2 ;
19021  PLINT arg3 ;
19022  PLINT arg4 ;
19023  PLINT arg5 ;
19024  PLINT arg6 ;
19025  double val1 ;
19026  int ecode1 = 0 ;
19027  double val2 ;
19028  int ecode2 = 0 ;
19029  int val3 ;
19030  int ecode3 = 0 ;
19031  int val4 ;
19032  int ecode4 = 0 ;
19033  int val5 ;
19034  int ecode5 = 0 ;
19035  int val6 ;
19036  int ecode6 = 0 ;
19037  octave_value_list _out;
19038  octave_value_list *_outp=&_out;
19039  octave_value _outv;
19040 
19041  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
19042  SWIG_fail;
19043  }
19044  ecode1 = SWIG_AsVal_double(args(0), &val1);
19045  if (!SWIG_IsOK(ecode1)) {
19046  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
19047  }
19048  arg1 = (PLFLT)(val1);
19049  ecode2 = SWIG_AsVal_double(args(1), &val2);
19050  if (!SWIG_IsOK(ecode2)) {
19051  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
19052  }
19053  arg2 = (PLFLT)(val2);
19054  ecode3 = SWIG_AsVal_int(args(2), &val3);
19055  if (!SWIG_IsOK(ecode3)) {
19056  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
19057  }
19058  arg3 = (PLINT)(val3);
19059  ecode4 = SWIG_AsVal_int(args(3), &val4);
19060  if (!SWIG_IsOK(ecode4)) {
19061  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
19062  }
19063  arg4 = (PLINT)(val4);
19064  ecode5 = SWIG_AsVal_int(args(4), &val5);
19065  if (!SWIG_IsOK(ecode5)) {
19066  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
19067  }
19068  arg5 = (PLINT)(val5);
19069  ecode6 = SWIG_AsVal_int(args(5), &val6);
19070  if (!SWIG_IsOK(ecode6)) {
19071  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
19072  }
19073  arg6 = (PLINT)(val6);
19074  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
19075  _outv = octave_value();
19076  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19077 fail:
19078  return _out;
19079 }
19080 
19081 
19082 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
19083  char *arg1 = (char *) 0 ;
19084  int res1 ;
19085  char *buf1 = 0 ;
19086  int alloc1 = 0 ;
19087  octave_value_list _out;
19088  octave_value_list *_outp=&_out;
19089  octave_value _outv;
19090 
19091  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
19092  SWIG_fail;
19093  }
19094  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19095  if (!SWIG_IsOK(res1)) {
19096  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
19097  }
19098  arg1 = (char *)(buf1);
19099  plspal0((char const *)arg1);
19100  _outv = octave_value();
19101  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19102  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19103 fail:
19104  return _out;
19105 }
19106 
19107 
19108 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
19109  char *arg1 = (char *) 0 ;
19110  PLBOOL arg2 ;
19111  int res1 ;
19112  char *buf1 = 0 ;
19113  int alloc1 = 0 ;
19114  int val2 ;
19115  int ecode2 = 0 ;
19116  octave_value_list _out;
19117  octave_value_list *_outp=&_out;
19118  octave_value _outv;
19119 
19120  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
19121  SWIG_fail;
19122  }
19123  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19124  if (!SWIG_IsOK(res1)) {
19125  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
19126  }
19127  arg1 = (char *)(buf1);
19128  ecode2 = SWIG_AsVal_int(args(1), &val2);
19129  if (!SWIG_IsOK(ecode2)) {
19130  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
19131  }
19132  arg2 = (PLBOOL)(val2);
19133  plspal1((char const *)arg1,arg2);
19134  _outv = octave_value();
19135  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19136  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19137 fail:
19138  return _out;
19139 }
19140 
19141 
19142 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
19143  PLBOOL arg1 ;
19144  int val1 ;
19145  int ecode1 = 0 ;
19146  octave_value_list _out;
19147  octave_value_list *_outp=&_out;
19148  octave_value _outv;
19149 
19150  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
19151  SWIG_fail;
19152  }
19153  ecode1 = SWIG_AsVal_int(args(0), &val1);
19154  if (!SWIG_IsOK(ecode1)) {
19155  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
19156  }
19157  arg1 = (PLBOOL)(val1);
19158  plspause(arg1);
19159  _outv = octave_value();
19160  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19161 fail:
19162  return _out;
19163 }
19164 
19165 
19166 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
19167  PLINT arg1 ;
19168  int val1 ;
19169  int ecode1 = 0 ;
19170  octave_value_list _out;
19171  octave_value_list *_outp=&_out;
19172  octave_value _outv;
19173 
19174  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
19175  SWIG_fail;
19176  }
19177  ecode1 = SWIG_AsVal_int(args(0), &val1);
19178  if (!SWIG_IsOK(ecode1)) {
19179  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
19180  }
19181  arg1 = (PLINT)(val1);
19182  plsstrm(arg1);
19183  _outv = octave_value();
19184  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19185 fail:
19186  return _out;
19187 }
19188 
19189 
19190 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
19191  PLINT arg1 ;
19192  PLINT arg2 ;
19193  int val1 ;
19194  int ecode1 = 0 ;
19195  int val2 ;
19196  int ecode2 = 0 ;
19197  octave_value_list _out;
19198  octave_value_list *_outp=&_out;
19199  octave_value _outv;
19200 
19201  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
19202  SWIG_fail;
19203  }
19204  ecode1 = SWIG_AsVal_int(args(0), &val1);
19205  if (!SWIG_IsOK(ecode1)) {
19206  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
19207  }
19208  arg1 = (PLINT)(val1);
19209  ecode2 = SWIG_AsVal_int(args(1), &val2);
19210  if (!SWIG_IsOK(ecode2)) {
19211  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
19212  }
19213  arg2 = (PLINT)(val2);
19214  plssub(arg1,arg2);
19215  _outv = octave_value();
19216  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19217 fail:
19218  return _out;
19219 }
19220 
19221 
19222 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
19223  PLFLT arg1 ;
19224  PLFLT arg2 ;
19225  double val1 ;
19226  int ecode1 = 0 ;
19227  double val2 ;
19228  int ecode2 = 0 ;
19229  octave_value_list _out;
19230  octave_value_list *_outp=&_out;
19231  octave_value _outv;
19232 
19233  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
19234  SWIG_fail;
19235  }
19236  ecode1 = SWIG_AsVal_double(args(0), &val1);
19237  if (!SWIG_IsOK(ecode1)) {
19238  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
19239  }
19240  arg1 = (PLFLT)(val1);
19241  ecode2 = SWIG_AsVal_double(args(1), &val2);
19242  if (!SWIG_IsOK(ecode2)) {
19243  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
19244  }
19245  arg2 = (PLFLT)(val2);
19246  plssym(arg1,arg2);
19247  _outv = octave_value();
19248  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19249 fail:
19250  return _out;
19251 }
19252 
19253 
19254 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
19255  PLINT arg1 ;
19256  PLINT arg2 ;
19257  int val1 ;
19258  int ecode1 = 0 ;
19259  int val2 ;
19260  int ecode2 = 0 ;
19261  octave_value_list _out;
19262  octave_value_list *_outp=&_out;
19263  octave_value _outv;
19264 
19265  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
19266  SWIG_fail;
19267  }
19268  ecode1 = SWIG_AsVal_int(args(0), &val1);
19269  if (!SWIG_IsOK(ecode1)) {
19270  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
19271  }
19272  arg1 = (PLINT)(val1);
19273  ecode2 = SWIG_AsVal_int(args(1), &val2);
19274  if (!SWIG_IsOK(ecode2)) {
19275  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
19276  }
19277  arg2 = (PLINT)(val2);
19278  plstar(arg1,arg2);
19279  _outv = octave_value();
19280  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19281 fail:
19282  return _out;
19283 }
19284 
19285 
19286 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
19287  char *arg1 = (char *) 0 ;
19288  PLINT arg2 ;
19289  PLINT arg3 ;
19290  int res1 ;
19291  char *buf1 = 0 ;
19292  int alloc1 = 0 ;
19293  int val2 ;
19294  int ecode2 = 0 ;
19295  int val3 ;
19296  int ecode3 = 0 ;
19297  octave_value_list _out;
19298  octave_value_list *_outp=&_out;
19299  octave_value _outv;
19300 
19301  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
19302  SWIG_fail;
19303  }
19304  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19305  if (!SWIG_IsOK(res1)) {
19306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
19307  }
19308  arg1 = (char *)(buf1);
19309  ecode2 = SWIG_AsVal_int(args(1), &val2);
19310  if (!SWIG_IsOK(ecode2)) {
19311  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
19312  }
19313  arg2 = (PLINT)(val2);
19314  ecode3 = SWIG_AsVal_int(args(2), &val3);
19315  if (!SWIG_IsOK(ecode3)) {
19316  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
19317  }
19318  arg3 = (PLINT)(val3);
19319  plstart((char const *)arg1,arg2,arg3);
19320  _outv = octave_value();
19321  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19322  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19323 fail:
19324  return _out;
19325 }
19326 
19327 
19328 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
19329  ct_func arg1 = (ct_func) 0 ;
19330  PLPointer arg2 = (PLPointer) 0 ;
19331  int res2 ;
19332  octave_value_list _out;
19333  octave_value_list *_outp=&_out;
19334  octave_value _outv;
19335 
19336  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
19337  SWIG_fail;
19338  }
19339  {
19340  octave_value obj = args(0);
19341  if ( !obj.is_empty() )
19342  {
19343  if ( obj.is_function_handle() || obj.is_inline_function() )
19344  {
19345  fcnCoordTrans = obj.function_value();
19346  }
19347  else if ( obj.is_string() )
19348  {
19349  nameCoordTrans = obj.string_value();
19350  fcnCoordTrans = NULL;
19351  }
19352  arg1 = ct_octave;
19353  }
19354  else
19355  {
19356  arg1 = NULL;
19357  }
19358  }
19359  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
19360  if (!SWIG_IsOK(res2)) {
19361  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
19362  }
19363  plstransform(arg1,arg2);
19364  _outv = octave_value();
19365  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19366 fail:
19367  return _out;
19368 }
19369 
19370 
19371 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
19372  PLINT arg1 ;
19373  PLFLT *arg2 = (PLFLT *) 0 ;
19374  PLFLT *arg3 = (PLFLT *) 0 ;
19375  char *arg4 = (char *) 0 ;
19376  Matrix temp1 ;
19377  Matrix temp3 ;
19378  int res4 ;
19379  char *buf4 = 0 ;
19380  int alloc4 = 0 ;
19381  octave_value_list _out;
19382  octave_value_list *_outp=&_out;
19383  octave_value _outv;
19384 
19385  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
19386  SWIG_fail;
19387  }
19388  {
19389  if ( _n_dims( args(0) ) > 1 )
19390  {
19391  error( "argument must be a scalar or vector" ); SWIG_fail;
19392  }
19393  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19394  temp1 = args(0).matrix_value();
19395  arg2 = &temp1( 0, 0 );
19396  }
19397  {
19398  if ( _n_dims( args(1) ) > 1 )
19399  {
19400  error( "argument must be a scalar or vector" ); SWIG_fail;
19401  }
19402  if ( _dim( args(1), 0 ) != Alen )
19403  {
19404  error( "argument vectors must be same length" ); SWIG_fail;
19405  }
19406  temp3 = args(1).matrix_value();
19407  arg3 = &temp3( 0, 0 );
19408  }
19409  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
19410  if (!SWIG_IsOK(res4)) {
19411  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
19412  }
19413  arg4 = (char *)(buf4);
19414  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
19415  _outv = octave_value();
19416  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19417  {
19418 
19419  }
19420  {
19421 
19422  }
19423  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
19424 fail:
19425  return _out;
19426 }
19427 
19428 
19429 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
19430  PLINT arg1 ;
19431  PLFLT *arg2 = (PLFLT *) 0 ;
19432  PLFLT *arg3 = (PLFLT *) 0 ;
19433  PLFLT *arg4 = (PLFLT *) 0 ;
19434  char *arg5 = (char *) 0 ;
19435  Matrix temp1 ;
19436  Matrix temp3 ;
19437  Matrix temp4 ;
19438  int res5 ;
19439  char *buf5 = 0 ;
19440  int alloc5 = 0 ;
19441  octave_value_list _out;
19442  octave_value_list *_outp=&_out;
19443  octave_value _outv;
19444 
19445  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
19446  SWIG_fail;
19447  }
19448  {
19449  if ( _n_dims( args(0) ) > 1 )
19450  {
19451  error( "argument must be a scalar or vector" ); SWIG_fail;
19452  }
19453  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19454  temp1 = args(0).matrix_value();
19455  arg2 = &temp1( 0, 0 );
19456  }
19457  {
19458  if ( _n_dims( args(1) ) > 1 )
19459  {
19460  error( "argument must be a scalar or vector" ); SWIG_fail;
19461  }
19462  if ( _dim( args(1), 0 ) != Alen )
19463  {
19464  error( "argument vectors must be same length" ); SWIG_fail;
19465  }
19466  temp3 = args(1).matrix_value();
19467  arg3 = &temp3( 0, 0 );
19468  }
19469  {
19470  if ( _n_dims( args(2) ) > 1 )
19471  {
19472  error( "argument must be a scalar or vector" ); SWIG_fail;
19473  }
19474  if ( _dim( args(2), 0 ) != Alen )
19475  {
19476  error( "argument vectors must be same length" ); SWIG_fail;
19477  }
19478  temp4 = args(2).matrix_value();
19479  arg4 = &temp4( 0, 0 );
19480  }
19481  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
19482  if (!SWIG_IsOK(res5)) {
19483  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
19484  }
19485  arg5 = (char *)(buf5);
19486  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
19487  _outv = octave_value();
19488  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19489  {
19490 
19491  }
19492  {
19493 
19494  }
19495  {
19496 
19497  }
19498  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19499 fail:
19500  return _out;
19501 }
19502 
19503 
19504 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
19505  PLINT arg1 ;
19506  PLINT arg2 ;
19507  PLFLT arg3 ;
19508  PLFLT arg4 ;
19509  int val1 ;
19510  int ecode1 = 0 ;
19511  int val2 ;
19512  int ecode2 = 0 ;
19513  double val3 ;
19514  int ecode3 = 0 ;
19515  double val4 ;
19516  int ecode4 = 0 ;
19517  octave_value_list _out;
19518  octave_value_list *_outp=&_out;
19519  octave_value _outv;
19520 
19521  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
19522  SWIG_fail;
19523  }
19524  ecode1 = SWIG_AsVal_int(args(0), &val1);
19525  if (!SWIG_IsOK(ecode1)) {
19526  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
19527  }
19528  arg1 = (PLINT)(val1);
19529  ecode2 = SWIG_AsVal_int(args(1), &val2);
19530  if (!SWIG_IsOK(ecode2)) {
19531  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
19532  }
19533  arg2 = (PLINT)(val2);
19534  ecode3 = SWIG_AsVal_double(args(2), &val3);
19535  if (!SWIG_IsOK(ecode3)) {
19536  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
19537  }
19538  arg3 = (PLFLT)(val3);
19539  ecode4 = SWIG_AsVal_double(args(3), &val4);
19540  if (!SWIG_IsOK(ecode4)) {
19541  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
19542  }
19543  arg4 = (PLFLT)(val4);
19544  plstripa(arg1,arg2,arg3,arg4);
19545  _outv = octave_value();
19546  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19547 fail:
19548  return _out;
19549 }
19550 
19551 
19552 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
19553  PLINT arg1 ;
19554  int val1 ;
19555  int ecode1 = 0 ;
19556  octave_value_list _out;
19557  octave_value_list *_outp=&_out;
19558  octave_value _outv;
19559 
19560  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
19561  SWIG_fail;
19562  }
19563  ecode1 = SWIG_AsVal_int(args(0), &val1);
19564  if (!SWIG_IsOK(ecode1)) {
19565  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
19566  }
19567  arg1 = (PLINT)(val1);
19568  plstripd(arg1);
19569  _outv = octave_value();
19570  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19571 fail:
19572  return _out;
19573 }
19574 
19575 
19576 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
19577  PLINT arg1 ;
19578  PLINT *arg2 = (PLINT *) 0 ;
19579  PLINT *arg3 = (PLINT *) 0 ;
19580  Matrix temp1 ;
19581  Matrix temp3 ;
19582  octave_value_list _out;
19583  octave_value_list *_outp=&_out;
19584  octave_value _outv;
19585 
19586  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
19587  SWIG_fail;
19588  }
19589  {
19590  if ( _n_dims( args(0) ) > 1 )
19591  {
19592  error( "argument must be a scalar or vector" ); SWIG_fail;
19593  }
19594  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19595  arg2 = new PLINT[Alen];
19596  temp1 = args(0).matrix_value();
19597  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
19598  }
19599  {
19600  if ( _n_dims( args(1) ) > 1 )
19601  {
19602  error( "argument must be a scalar or vector" ); SWIG_fail;
19603  }
19604  if ( _dim( args(1), 0 ) != Alen )
19605  {
19606  error( "argument vectors must be same length" ); SWIG_fail;
19607  }
19608  temp3 = args(1).matrix_value();
19609  arg3 = new PLINT[Alen];
19610  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19611  }
19612  plstyl(arg1,(int const *)arg2,(int const *)arg3);
19613  _outv = octave_value();
19614  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19615  {
19616  delete [] arg2;
19617  }
19618  {
19619  delete [] arg3;
19620  }
19621 fail:
19622  return _out;
19623 }
19624 
19625 
19626 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
19627  PLFLT *arg1 = (PLFLT *) 0 ;
19628  PLFLT *arg2 = (PLFLT *) 0 ;
19629  PLINT arg3 ;
19630  PLBOOL arg4 ;
19631  Matrix temp1 ;
19632  Matrix temp2 ;
19633  int val4 ;
19634  int ecode4 = 0 ;
19635  octave_value_list _out;
19636  octave_value_list *_outp=&_out;
19637  octave_value _outv;
19638 
19639  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
19640  SWIG_fail;
19641  }
19642  {
19643  if ( _n_dims( args(0) ) > 1 )
19644  {
19645  error( "argument must be a scalar or vector" ); SWIG_fail;
19646  }
19647  if ( !args(0).is_empty() )
19648  {
19649  Alen = (PLINT) ( _dim( args(0), 0 ) );
19650  temp1 = args(0).matrix_value();
19651  arg1 = &temp1( 0, 0 );
19652  }
19653  else
19654  {
19655  arg1 = NULL;
19656  Alen = 0;
19657  }
19658  }
19659  {
19660  if ( _n_dims( args(1) ) > 1 )
19661  {
19662  error( "argument must be a scalar or vector" ); SWIG_fail;
19663  }
19664  if ( !args(1).is_empty() )
19665  {
19666  if ( _dim( args(1), 0 ) != Alen )
19667  {
19668  error( "argument vectors must be same length" ); SWIG_fail;
19669  }
19670  temp2 = args(1).matrix_value();
19671  arg2 = &temp2( 0, 0 );
19672  arg3 = (PLINT) ( _dim( args(1), 0 ) );
19673  }
19674  else
19675  {
19676  arg2 = NULL;
19677  arg3 = 0;
19678  }
19679  }
19680  ecode4 = SWIG_AsVal_int(args(2), &val4);
19681  if (!SWIG_IsOK(ecode4)) {
19682  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
19683  }
19684  arg4 = (PLBOOL)(val4);
19685  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
19686  _outv = octave_value();
19687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19688  {
19689 
19690  }
19691  {
19692 
19693  }
19694 fail:
19695  return _out;
19696 }
19697 
19698 
19699 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
19700  PLFLT arg1 ;
19701  PLFLT arg2 ;
19702  PLFLT arg3 ;
19703  PLFLT arg4 ;
19704  double val1 ;
19705  int ecode1 = 0 ;
19706  double val2 ;
19707  int ecode2 = 0 ;
19708  double val3 ;
19709  int ecode3 = 0 ;
19710  double val4 ;
19711  int ecode4 = 0 ;
19712  octave_value_list _out;
19713  octave_value_list *_outp=&_out;
19714  octave_value _outv;
19715 
19716  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
19717  SWIG_fail;
19718  }
19719  ecode1 = SWIG_AsVal_double(args(0), &val1);
19720  if (!SWIG_IsOK(ecode1)) {
19721  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
19722  }
19723  arg1 = (PLFLT)(val1);
19724  ecode2 = SWIG_AsVal_double(args(1), &val2);
19725  if (!SWIG_IsOK(ecode2)) {
19726  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
19727  }
19728  arg2 = (PLFLT)(val2);
19729  ecode3 = SWIG_AsVal_double(args(2), &val3);
19730  if (!SWIG_IsOK(ecode3)) {
19731  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
19732  }
19733  arg3 = (PLFLT)(val3);
19734  ecode4 = SWIG_AsVal_double(args(3), &val4);
19735  if (!SWIG_IsOK(ecode4)) {
19736  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
19737  }
19738  arg4 = (PLFLT)(val4);
19739  plsvpa(arg1,arg2,arg3,arg4);
19740  _outv = octave_value();
19741  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19742 fail:
19743  return _out;
19744 }
19745 
19746 
19747 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
19748  PLINT arg1 ;
19749  PLINT arg2 ;
19750  int val1 ;
19751  int ecode1 = 0 ;
19752  int val2 ;
19753  int ecode2 = 0 ;
19754  octave_value_list _out;
19755  octave_value_list *_outp=&_out;
19756  octave_value _outv;
19757 
19758  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
19759  SWIG_fail;
19760  }
19761  ecode1 = SWIG_AsVal_int(args(0), &val1);
19762  if (!SWIG_IsOK(ecode1)) {
19763  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
19764  }
19765  arg1 = (PLINT)(val1);
19766  ecode2 = SWIG_AsVal_int(args(1), &val2);
19767  if (!SWIG_IsOK(ecode2)) {
19768  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
19769  }
19770  arg2 = (PLINT)(val2);
19771  plsxax(arg1,arg2);
19772  _outv = octave_value();
19773  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19774 fail:
19775  return _out;
19776 }
19777 
19778 
19779 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
19780  PLINT arg1 ;
19781  PLINT arg2 ;
19782  int val1 ;
19783  int ecode1 = 0 ;
19784  int val2 ;
19785  int ecode2 = 0 ;
19786  octave_value_list _out;
19787  octave_value_list *_outp=&_out;
19788  octave_value _outv;
19789 
19790  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
19791  SWIG_fail;
19792  }
19793  ecode1 = SWIG_AsVal_int(args(0), &val1);
19794  if (!SWIG_IsOK(ecode1)) {
19795  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
19796  }
19797  arg1 = (PLINT)(val1);
19798  ecode2 = SWIG_AsVal_int(args(1), &val2);
19799  if (!SWIG_IsOK(ecode2)) {
19800  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
19801  }
19802  arg2 = (PLINT)(val2);
19803  plsyax(arg1,arg2);
19804  _outv = octave_value();
19805  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19806 fail:
19807  return _out;
19808 }
19809 
19810 
19811 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
19812  PLINT arg1 ;
19813  PLFLT *arg2 = (PLFLT *) 0 ;
19814  PLFLT *arg3 = (PLFLT *) 0 ;
19815  PLINT arg4 ;
19816  Matrix temp1 ;
19817  Matrix temp3 ;
19818  int val4 ;
19819  int ecode4 = 0 ;
19820  octave_value_list _out;
19821  octave_value_list *_outp=&_out;
19822  octave_value _outv;
19823 
19824  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
19825  SWIG_fail;
19826  }
19827  {
19828  if ( _n_dims( args(0) ) > 1 )
19829  {
19830  error( "argument must be a scalar or vector" ); SWIG_fail;
19831  }
19832  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19833  temp1 = args(0).matrix_value();
19834  arg2 = &temp1( 0, 0 );
19835  }
19836  {
19837  if ( _n_dims( args(1) ) > 1 )
19838  {
19839  error( "argument must be a scalar or vector" ); SWIG_fail;
19840  }
19841  if ( _dim( args(1), 0 ) != Alen )
19842  {
19843  error( "argument vectors must be same length" ); SWIG_fail;
19844  }
19845  temp3 = args(1).matrix_value();
19846  arg3 = &temp3( 0, 0 );
19847  }
19848  ecode4 = SWIG_AsVal_int(args(2), &val4);
19849  if (!SWIG_IsOK(ecode4)) {
19850  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
19851  }
19852  arg4 = (PLINT)(val4);
19853  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
19854  _outv = octave_value();
19855  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19856  {
19857 
19858  }
19859  {
19860 
19861  }
19862 fail:
19863  return _out;
19864 }
19865 
19866 
19867 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
19868  PLINT arg1 ;
19869  PLINT arg2 ;
19870  int val1 ;
19871  int ecode1 = 0 ;
19872  int val2 ;
19873  int ecode2 = 0 ;
19874  octave_value_list _out;
19875  octave_value_list *_outp=&_out;
19876  octave_value _outv;
19877 
19878  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
19879  SWIG_fail;
19880  }
19881  ecode1 = SWIG_AsVal_int(args(0), &val1);
19882  if (!SWIG_IsOK(ecode1)) {
19883  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
19884  }
19885  arg1 = (PLINT)(val1);
19886  ecode2 = SWIG_AsVal_int(args(1), &val2);
19887  if (!SWIG_IsOK(ecode2)) {
19888  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
19889  }
19890  arg2 = (PLINT)(val2);
19891  plszax(arg1,arg2);
19892  _outv = octave_value();
19893  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19894 fail:
19895  return _out;
19896 }
19897 
19898 
19899 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
19900  octave_value_list _out;
19901  octave_value_list *_outp=&_out;
19902  octave_value _outv;
19903 
19904  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
19905  SWIG_fail;
19906  }
19907  pltext();
19908  _outv = octave_value();
19909  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19910 fail:
19911  return _out;
19912 }
19913 
19914 
19915 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
19916  char *arg1 = (char *) 0 ;
19917  int res1 ;
19918  char *buf1 = 0 ;
19919  int alloc1 = 0 ;
19920  octave_value_list _out;
19921  octave_value_list *_outp=&_out;
19922  octave_value _outv;
19923 
19924  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
19925  SWIG_fail;
19926  }
19927  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19928  if (!SWIG_IsOK(res1)) {
19929  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
19930  }
19931  arg1 = (char *)(buf1);
19932  pltimefmt((char const *)arg1);
19933  _outv = octave_value();
19934  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19935  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19936 fail:
19937  return _out;
19938 }
19939 
19940 
19941 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
19942  PLFLT arg1 ;
19943  double val1 ;
19944  int ecode1 = 0 ;
19945  octave_value_list _out;
19946  octave_value_list *_outp=&_out;
19947  octave_value _outv;
19948 
19949  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
19950  SWIG_fail;
19951  }
19952  ecode1 = SWIG_AsVal_double(args(0), &val1);
19953  if (!SWIG_IsOK(ecode1)) {
19954  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
19955  }
19956  arg1 = (PLFLT)(val1);
19957  plvasp(arg1);
19958  _outv = octave_value();
19959  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19960 fail:
19961  return _out;
19962 }
19963 
19964 
19965 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
19966  PLFLT arg1 ;
19967  PLFLT arg2 ;
19968  PLFLT arg3 ;
19969  PLFLT arg4 ;
19970  PLFLT arg5 ;
19971  double val1 ;
19972  int ecode1 = 0 ;
19973  double val2 ;
19974  int ecode2 = 0 ;
19975  double val3 ;
19976  int ecode3 = 0 ;
19977  double val4 ;
19978  int ecode4 = 0 ;
19979  double val5 ;
19980  int ecode5 = 0 ;
19981  octave_value_list _out;
19982  octave_value_list *_outp=&_out;
19983  octave_value _outv;
19984 
19985  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
19986  SWIG_fail;
19987  }
19988  ecode1 = SWIG_AsVal_double(args(0), &val1);
19989  if (!SWIG_IsOK(ecode1)) {
19990  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
19991  }
19992  arg1 = (PLFLT)(val1);
19993  ecode2 = SWIG_AsVal_double(args(1), &val2);
19994  if (!SWIG_IsOK(ecode2)) {
19995  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
19996  }
19997  arg2 = (PLFLT)(val2);
19998  ecode3 = SWIG_AsVal_double(args(2), &val3);
19999  if (!SWIG_IsOK(ecode3)) {
20000  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
20001  }
20002  arg3 = (PLFLT)(val3);
20003  ecode4 = SWIG_AsVal_double(args(3), &val4);
20004  if (!SWIG_IsOK(ecode4)) {
20005  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
20006  }
20007  arg4 = (PLFLT)(val4);
20008  ecode5 = SWIG_AsVal_double(args(4), &val5);
20009  if (!SWIG_IsOK(ecode5)) {
20010  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
20011  }
20012  arg5 = (PLFLT)(val5);
20013  plvpas(arg1,arg2,arg3,arg4,arg5);
20014  _outv = octave_value();
20015  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20016 fail:
20017  return _out;
20018 }
20019 
20020 
20021 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
20022  PLFLT arg1 ;
20023  PLFLT arg2 ;
20024  PLFLT arg3 ;
20025  PLFLT arg4 ;
20026  double val1 ;
20027  int ecode1 = 0 ;
20028  double val2 ;
20029  int ecode2 = 0 ;
20030  double val3 ;
20031  int ecode3 = 0 ;
20032  double val4 ;
20033  int ecode4 = 0 ;
20034  octave_value_list _out;
20035  octave_value_list *_outp=&_out;
20036  octave_value _outv;
20037 
20038  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
20039  SWIG_fail;
20040  }
20041  ecode1 = SWIG_AsVal_double(args(0), &val1);
20042  if (!SWIG_IsOK(ecode1)) {
20043  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
20044  }
20045  arg1 = (PLFLT)(val1);
20046  ecode2 = SWIG_AsVal_double(args(1), &val2);
20047  if (!SWIG_IsOK(ecode2)) {
20048  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
20049  }
20050  arg2 = (PLFLT)(val2);
20051  ecode3 = SWIG_AsVal_double(args(2), &val3);
20052  if (!SWIG_IsOK(ecode3)) {
20053  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
20054  }
20055  arg3 = (PLFLT)(val3);
20056  ecode4 = SWIG_AsVal_double(args(3), &val4);
20057  if (!SWIG_IsOK(ecode4)) {
20058  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
20059  }
20060  arg4 = (PLFLT)(val4);
20061  plvpor(arg1,arg2,arg3,arg4);
20062  _outv = octave_value();
20063  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20064 fail:
20065  return _out;
20066 }
20067 
20068 
20069 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
20070  octave_value_list _out;
20071  octave_value_list *_outp=&_out;
20072  octave_value _outv;
20073 
20074  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
20075  SWIG_fail;
20076  }
20077  plvsta();
20078  _outv = octave_value();
20079  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20080 fail:
20081  return _out;
20082 }
20083 
20084 
20085 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
20086  PLFLT arg1 ;
20087  PLFLT arg2 ;
20088  PLFLT arg3 ;
20089  PLFLT arg4 ;
20090  PLFLT arg5 ;
20091  PLFLT arg6 ;
20092  PLFLT arg7 ;
20093  PLFLT arg8 ;
20094  PLFLT arg9 ;
20095  PLFLT arg10 ;
20096  PLFLT arg11 ;
20097  double val1 ;
20098  int ecode1 = 0 ;
20099  double val2 ;
20100  int ecode2 = 0 ;
20101  double val3 ;
20102  int ecode3 = 0 ;
20103  double val4 ;
20104  int ecode4 = 0 ;
20105  double val5 ;
20106  int ecode5 = 0 ;
20107  double val6 ;
20108  int ecode6 = 0 ;
20109  double val7 ;
20110  int ecode7 = 0 ;
20111  double val8 ;
20112  int ecode8 = 0 ;
20113  double val9 ;
20114  int ecode9 = 0 ;
20115  double val10 ;
20116  int ecode10 = 0 ;
20117  double val11 ;
20118  int ecode11 = 0 ;
20119  octave_value_list _out;
20120  octave_value_list *_outp=&_out;
20121  octave_value _outv;
20122 
20123  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
20124  SWIG_fail;
20125  }
20126  ecode1 = SWIG_AsVal_double(args(0), &val1);
20127  if (!SWIG_IsOK(ecode1)) {
20128  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
20129  }
20130  arg1 = (PLFLT)(val1);
20131  ecode2 = SWIG_AsVal_double(args(1), &val2);
20132  if (!SWIG_IsOK(ecode2)) {
20133  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
20134  }
20135  arg2 = (PLFLT)(val2);
20136  ecode3 = SWIG_AsVal_double(args(2), &val3);
20137  if (!SWIG_IsOK(ecode3)) {
20138  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
20139  }
20140  arg3 = (PLFLT)(val3);
20141  ecode4 = SWIG_AsVal_double(args(3), &val4);
20142  if (!SWIG_IsOK(ecode4)) {
20143  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
20144  }
20145  arg4 = (PLFLT)(val4);
20146  ecode5 = SWIG_AsVal_double(args(4), &val5);
20147  if (!SWIG_IsOK(ecode5)) {
20148  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
20149  }
20150  arg5 = (PLFLT)(val5);
20151  ecode6 = SWIG_AsVal_double(args(5), &val6);
20152  if (!SWIG_IsOK(ecode6)) {
20153  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
20154  }
20155  arg6 = (PLFLT)(val6);
20156  ecode7 = SWIG_AsVal_double(args(6), &val7);
20157  if (!SWIG_IsOK(ecode7)) {
20158  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
20159  }
20160  arg7 = (PLFLT)(val7);
20161  ecode8 = SWIG_AsVal_double(args(7), &val8);
20162  if (!SWIG_IsOK(ecode8)) {
20163  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
20164  }
20165  arg8 = (PLFLT)(val8);
20166  ecode9 = SWIG_AsVal_double(args(8), &val9);
20167  if (!SWIG_IsOK(ecode9)) {
20168  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
20169  }
20170  arg9 = (PLFLT)(val9);
20171  ecode10 = SWIG_AsVal_double(args(9), &val10);
20172  if (!SWIG_IsOK(ecode10)) {
20173  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
20174  }
20175  arg10 = (PLFLT)(val10);
20176  ecode11 = SWIG_AsVal_double(args(10), &val11);
20177  if (!SWIG_IsOK(ecode11)) {
20178  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
20179  }
20180  arg11 = (PLFLT)(val11);
20181  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
20182  _outv = octave_value();
20183  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20184 fail:
20185  return _out;
20186 }
20187 
20188 
20189 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
20190  PLINT arg1 ;
20191  int val1 ;
20192  int ecode1 = 0 ;
20193  octave_value_list _out;
20194  octave_value_list *_outp=&_out;
20195  octave_value _outv;
20196 
20197  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
20198  SWIG_fail;
20199  }
20200  ecode1 = SWIG_AsVal_int(args(0), &val1);
20201  if (!SWIG_IsOK(ecode1)) {
20202  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
20203  }
20204  arg1 = (PLINT)(val1);
20205  plwidth(arg1);
20206  _outv = octave_value();
20207  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20208 fail:
20209  return _out;
20210 }
20211 
20212 
20213 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
20214  PLFLT arg1 ;
20215  PLFLT arg2 ;
20216  PLFLT arg3 ;
20217  PLFLT arg4 ;
20218  double val1 ;
20219  int ecode1 = 0 ;
20220  double val2 ;
20221  int ecode2 = 0 ;
20222  double val3 ;
20223  int ecode3 = 0 ;
20224  double val4 ;
20225  int ecode4 = 0 ;
20226  octave_value_list _out;
20227  octave_value_list *_outp=&_out;
20228  octave_value _outv;
20229 
20230  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
20231  SWIG_fail;
20232  }
20233  ecode1 = SWIG_AsVal_double(args(0), &val1);
20234  if (!SWIG_IsOK(ecode1)) {
20235  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
20236  }
20237  arg1 = (PLFLT)(val1);
20238  ecode2 = SWIG_AsVal_double(args(1), &val2);
20239  if (!SWIG_IsOK(ecode2)) {
20240  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
20241  }
20242  arg2 = (PLFLT)(val2);
20243  ecode3 = SWIG_AsVal_double(args(2), &val3);
20244  if (!SWIG_IsOK(ecode3)) {
20245  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
20246  }
20247  arg3 = (PLFLT)(val3);
20248  ecode4 = SWIG_AsVal_double(args(3), &val4);
20249  if (!SWIG_IsOK(ecode4)) {
20250  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
20251  }
20252  arg4 = (PLFLT)(val4);
20253  plwind(arg1,arg2,arg3,arg4);
20254  _outv = octave_value();
20255  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20256 fail:
20257  return _out;
20258 }
20259 
20260 
20261 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
20262  PLBOOL arg1 ;
20263  PLBOOL *arg2 = (PLBOOL *) 0 ;
20264  int val1 ;
20265  int ecode1 = 0 ;
20266  PLBOOL temp2 ;
20267  int res2 = SWIG_TMPOBJ ;
20268  octave_value_list _out;
20269  octave_value_list *_outp=&_out;
20270  octave_value _outv;
20271 
20272  arg2 = &temp2;
20273  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
20274  SWIG_fail;
20275  }
20276  ecode1 = SWIG_AsVal_int(args(0), &val1);
20277  if (!SWIG_IsOK(ecode1)) {
20278  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
20279  }
20280  arg1 = (PLBOOL)(val1);
20281  plxormod(arg1,arg2);
20282  _outv = octave_value();
20283  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20284  if (SWIG_IsTmpObj(res2)) {
20285  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20286  } else {
20287  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20288  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20289  }
20290 fail:
20291  return _out;
20292 }
20293 
20294 
20295 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
20296  mapform_func arg1 = (mapform_func) 0 ;
20297  char *arg2 = (char *) 0 ;
20298  PLFLT arg3 ;
20299  PLFLT arg4 ;
20300  PLFLT arg5 ;
20301  PLFLT arg6 ;
20302  int res2 ;
20303  char *buf2 = 0 ;
20304  int alloc2 = 0 ;
20305  double val3 ;
20306  int ecode3 = 0 ;
20307  double val4 ;
20308  int ecode4 = 0 ;
20309  double val5 ;
20310  int ecode5 = 0 ;
20311  double val6 ;
20312  int ecode6 = 0 ;
20313  octave_value_list _out;
20314  octave_value_list *_outp=&_out;
20315  octave_value _outv;
20316 
20317  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
20318  SWIG_fail;
20319  }
20320  {
20321  octave_value obj = args(0);
20322  if ( !obj.is_empty() )
20323  {
20324  if ( obj.is_function_handle() || obj.is_inline_function() )
20325  {
20326  fcnMapForm = obj.function_value();
20327  }
20328  else if ( obj.is_string() )
20329  {
20330  nameMapForm = obj.string_value();
20331  fcnMapForm = NULL;
20332  }
20333  arg1 = mapform_octave;
20334  }
20335  else
20336  {
20337  arg1 = NULL;
20338  }
20339  }
20340  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20341  if (!SWIG_IsOK(res2)) {
20342  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
20343  }
20344  arg2 = (char *)(buf2);
20345  ecode3 = SWIG_AsVal_double(args(2), &val3);
20346  if (!SWIG_IsOK(ecode3)) {
20347  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
20348  }
20349  arg3 = (PLFLT)(val3);
20350  ecode4 = SWIG_AsVal_double(args(3), &val4);
20351  if (!SWIG_IsOK(ecode4)) {
20352  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
20353  }
20354  arg4 = (PLFLT)(val4);
20355  ecode5 = SWIG_AsVal_double(args(4), &val5);
20356  if (!SWIG_IsOK(ecode5)) {
20357  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
20358  }
20359  arg5 = (PLFLT)(val5);
20360  ecode6 = SWIG_AsVal_double(args(5), &val6);
20361  if (!SWIG_IsOK(ecode6)) {
20362  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
20363  }
20364  arg6 = (PLFLT)(val6);
20365  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
20366  _outv = octave_value();
20367  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20368  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20369 fail:
20370  return _out;
20371 }
20372 
20373 
20374 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
20375  mapform_func arg1 = (mapform_func) 0 ;
20376  PLFLT arg2 ;
20377  PLFLT arg3 ;
20378  PLFLT arg4 ;
20379  PLFLT arg5 ;
20380  PLFLT arg6 ;
20381  PLFLT arg7 ;
20382  double val2 ;
20383  int ecode2 = 0 ;
20384  double val3 ;
20385  int ecode3 = 0 ;
20386  double val4 ;
20387  int ecode4 = 0 ;
20388  double val5 ;
20389  int ecode5 = 0 ;
20390  double val6 ;
20391  int ecode6 = 0 ;
20392  double val7 ;
20393  int ecode7 = 0 ;
20394  octave_value_list _out;
20395  octave_value_list *_outp=&_out;
20396  octave_value _outv;
20397 
20398  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
20399  SWIG_fail;
20400  }
20401  {
20402  octave_value obj = args(0);
20403  if ( !obj.is_empty() )
20404  {
20405  if ( obj.is_function_handle() || obj.is_inline_function() )
20406  {
20407  fcnMapForm = obj.function_value();
20408  }
20409  else if ( obj.is_string() )
20410  {
20411  nameMapForm = obj.string_value();
20412  fcnMapForm = NULL;
20413  }
20414  arg1 = mapform_octave;
20415  }
20416  else
20417  {
20418  arg1 = NULL;
20419  }
20420  }
20421  ecode2 = SWIG_AsVal_double(args(1), &val2);
20422  if (!SWIG_IsOK(ecode2)) {
20423  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
20424  }
20425  arg2 = (PLFLT)(val2);
20426  ecode3 = SWIG_AsVal_double(args(2), &val3);
20427  if (!SWIG_IsOK(ecode3)) {
20428  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
20429  }
20430  arg3 = (PLFLT)(val3);
20431  ecode4 = SWIG_AsVal_double(args(3), &val4);
20432  if (!SWIG_IsOK(ecode4)) {
20433  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
20434  }
20435  arg4 = (PLFLT)(val4);
20436  ecode5 = SWIG_AsVal_double(args(4), &val5);
20437  if (!SWIG_IsOK(ecode5)) {
20438  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
20439  }
20440  arg5 = (PLFLT)(val5);
20441  ecode6 = SWIG_AsVal_double(args(5), &val6);
20442  if (!SWIG_IsOK(ecode6)) {
20443  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
20444  }
20445  arg6 = (PLFLT)(val6);
20446  ecode7 = SWIG_AsVal_double(args(6), &val7);
20447  if (!SWIG_IsOK(ecode7)) {
20448  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
20449  }
20450  arg7 = (PLFLT)(val7);
20451  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20452  _outv = octave_value();
20453  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20454 fail:
20455  return _out;
20456 }
20457 
20458 
20460  octave_value_list _out;
20461  octave_value_list *_outp=&_out;
20462  octave_value _outv;
20463 
20464  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
20465  SWIG_fail;
20466  }
20467  plClearOpts();
20468  _outv = octave_value();
20469  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20470 fail:
20471  return _out;
20472 }
20473 
20474 
20476  octave_value_list _out;
20477  octave_value_list *_outp=&_out;
20478  octave_value _outv;
20479 
20480  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
20481  SWIG_fail;
20482  }
20483  plResetOpts();
20484  _outv = octave_value();
20485  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20486 fail:
20487  return _out;
20488 }
20489 
20490 
20492  char *arg1 = (char *) 0 ;
20493  char *arg2 = (char *) 0 ;
20494  int res1 ;
20495  char *buf1 = 0 ;
20496  int alloc1 = 0 ;
20497  int res2 ;
20498  char *buf2 = 0 ;
20499  int alloc2 = 0 ;
20500  octave_value_list _out;
20501  octave_value_list *_outp=&_out;
20502  octave_value _outv;
20503 
20504  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
20505  SWIG_fail;
20506  }
20507  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20508  if (!SWIG_IsOK(res1)) {
20509  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
20510  }
20511  arg1 = (char *)(buf1);
20512  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20513  if (!SWIG_IsOK(res2)) {
20514  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
20515  }
20516  arg2 = (char *)(buf2);
20517  plSetUsage((char const *)arg1,(char const *)arg2);
20518  _outv = octave_value();
20519  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20520  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20521  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20522 fail:
20523  return _out;
20524 }
20525 
20526 
20528  octave_value_list _out;
20529  octave_value_list *_outp=&_out;
20530  octave_value _outv;
20531 
20532  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
20533  SWIG_fail;
20534  }
20535  plOptUsage();
20536  _outv = octave_value();
20537  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20538 fail:
20539  return _out;
20540 }
20541 
20542 
20543 
20544 static const struct swig_octave_member swig_globals[] = {
20545 {"testppchar",_wrap_testppchar,0,0,2,0},
20546 {"plGetCursor",_wrap_plGetCursor,0,0,2,0},
20547 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
20548 {"plstripc",_wrap_plstripc,0,0,2,0},
20549 {"plcont",_wrap_plcont,0,0,2,0},
20550 {"plcont0",_wrap_plcont0,0,0,2,0},
20551 {"plcont1",_wrap_plcont1,0,0,2,0},
20552 {"plcont2",_wrap_plcont2,0,0,2,0},
20553 {"plcont2p",_wrap_plcont2p,0,0,2,0},
20554 {"plgriddata",_wrap_plgriddata,0,0,2,0},
20555 {"plmesh",_wrap_plmesh,0,0,2,0},
20556 {"plmeshc",_wrap_plmeshc,0,0,2,0},
20557 {"plot3d",_wrap_plot3d,0,0,2,0},
20558 {"plot3dc",_wrap_plot3dc,0,0,2,0},
20559 {"plsurf3d",_wrap_plsurf3d,0,0,2,0},
20560 {"plshade",_wrap_plshade,0,0,2,0},
20561 {"plshade1",_wrap_plshade1,0,0,2,0},
20562 {"plshade2",_wrap_plshade2,0,0,2,0},
20563 {"plshades",_wrap_plshades,0,0,2,0},
20564 {"plshadesx",_wrap_plshadesx,0,0,2,0},
20565 {"plshades1",_wrap_plshades1,0,0,2,0},
20566 {"plshades2",_wrap_plshades2,0,0,2,0},
20567 {"plvect",_wrap_plvect,0,0,2,0},
20568 {"plvect1",_wrap_plvect1,0,0,2,0},
20569 {"plvect2",_wrap_plvect2,0,0,2,0},
20570 {"pplimage",_wrap_pplimage,0,0,2,0},
20571 {"plimagefr",_wrap_plimagefr,0,0,2,0},
20572 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
20573 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
20574 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
20575 {"plcolorbar",_wrap_plcolorbar,0,0,2,0},
20576 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
20577 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
20578 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
20579 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
20580 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
20581 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
20582 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
20583 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
20584 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
20585 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
20586 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
20587 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
20588 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
20589 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
20590 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
20591 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
20592 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
20593 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
20594 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
20595 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
20596 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
20597 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
20598 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
20599 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
20600 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
20601 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
20602 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
20603 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
20604 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
20605 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
20606 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
20607 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
20608 {"plbtime",_wrap_plbtime,0,0,2,0},
20609 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
20610 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
20611 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
20612 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
20613 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
20614 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
20615 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
20616 {"plconfigtime",_wrap_plconfigtime,0,0,2,0},
20617 {"plctime",_wrap_plctime,0,0,2,0},
20618 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
20619 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
20620 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
20621 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
20622 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
20623 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
20624 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
20625 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
20626 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
20627 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
20628 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
20629 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
20630 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
20631 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
20632 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
20633 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
20634 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
20635 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
20636 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
20637 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
20638 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
20639 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
20640 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
20641 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
20642 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
20643 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
20644 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
20645 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
20646 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
20647 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
20648 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
20649 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
20650 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
20651 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
20652 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
20653 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
20654 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
20655 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
20656 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
20657 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
20658 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
20659 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
20660 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
20661 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
20662 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
20663 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
20664 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
20665 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
20666 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
20667 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
20668 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
20669 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
20670 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
20671 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
20672 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
20673 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
20674 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
20675 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
20676 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
20677 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
20678 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
20679 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
20680 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
20681 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
20682 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
20683 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
20684 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
20685 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
20686 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
20687 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
20688 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
20689 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
20690 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
20691 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
20692 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
20693 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,0},
20694 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,0},
20695 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
20696 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
20697 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
20698 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
20699 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
20700 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
20701 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
20702 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
20703 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
20704 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
20705 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
20706 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
20707 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
20708 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
20709 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
20710 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
20711 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
20712 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
20713 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
20714 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
20715 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
20716 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
20717 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
20718 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
20719 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
20720 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
20721 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
20722 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
20723 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
20724 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
20725 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
20726 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
20727 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
20728 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
20729 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
20730 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
20731 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
20732 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
20733 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
20734 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
20735 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
20736 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
20737 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
20738 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
20739 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
20740 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
20741 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
20742 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
20743 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
20744 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
20745 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
20746 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
20747 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
20748 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
20749 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
20750 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
20751 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
20752 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
20753 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
20754 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
20755 {0,0,0,0,0}
20756 };
20757 
20758 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20759 
20760 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
20761 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20762 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20763 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};
20764 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};
20765 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};
20766 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20767 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20768 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20769 
20772  &_swigt__p_char,
20777  &_swigt__p_int,
20780 };
20781 
20782 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20783 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20784 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20788 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20789 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20790 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20791 
20799  _swigc__p_int,
20802 };
20803 
20804 
20805 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20806 
20807 /* -----------------------------------------------------------------------------
20808  * Type initialization:
20809  * This problem is tough by the requirement that no dynamic
20810  * memory is used. Also, since swig_type_info structures store pointers to
20811  * swig_cast_info structures and swig_cast_info structures store pointers back
20812  * to swig_type_info structures, we need some lookup code at initialization.
20813  * The idea is that swig generates all the structures that are needed.
20814  * The runtime then collects these partially filled structures.
20815  * The SWIG_InitializeModule function takes these initial arrays out of
20816  * swig_module, and does all the lookup, filling in the swig_module.types
20817  * array with the correct data and linking the correct swig_cast_info
20818  * structures together.
20819  *
20820  * The generated swig_type_info structures are assigned staticly to an initial
20821  * array. We just loop through that array, and handle each type individually.
20822  * First we lookup if this type has been already loaded, and if so, use the
20823  * loaded structure instead of the generated one. Then we have to fill in the
20824  * cast linked list. The cast data is initially stored in something like a
20825  * two-dimensional array. Each row corresponds to a type (there are the same
20826  * number of rows as there are in the swig_type_initial array). Each entry in
20827  * a column is one of the swig_cast_info structures for that type.
20828  * The cast_initial array is actually an array of arrays, because each row has
20829  * a variable number of columns. So to actually build the cast linked list,
20830  * we find the array of casts associated with the type, and loop through it
20831  * adding the casts to the list. The one last trick we need to do is making
20832  * sure the type pointer in the swig_cast_info struct is correct.
20833  *
20834  * First off, we lookup the cast->type name to see if it is already loaded.
20835  * There are three cases to handle:
20836  * 1) If the cast->type has already been loaded AND the type we are adding
20837  * casting info to has not been loaded (it is in this module), THEN we
20838  * replace the cast->type pointer with the type pointer that has already
20839  * been loaded.
20840  * 2) If BOTH types (the one we are adding casting info to, and the
20841  * cast->type) are loaded, THEN the cast info has already been loaded by
20842  * the previous module so we just ignore it.
20843  * 3) Finally, if cast->type has not already been loaded, then we add that
20844  * swig_cast_info to the linked list (because the cast->type) pointer will
20845  * be correct.
20846  * ----------------------------------------------------------------------------- */
20847 
20848 #ifdef __cplusplus
20849 extern "C" {
20850 #if 0
20851 } /* c-mode */
20852 #endif
20853 #endif
20854 
20855 #if 0
20856 #define SWIGRUNTIME_DEBUG
20857 #endif
20858 
20859 
20860 SWIGRUNTIME void
20861 SWIG_InitializeModule(void *clientdata) {
20862  size_t i;
20863  swig_module_info *module_head, *iter;
20864  int found, init;
20865 
20866  clientdata = clientdata;
20867 
20868  /* check to see if the circular list has been setup, if not, set it up */
20869  if (swig_module.next==0) {
20870  /* Initialize the swig_module */
20871  swig_module.type_initial = swig_type_initial;
20872  swig_module.cast_initial = swig_cast_initial;
20873  swig_module.next = &swig_module;
20874  init = 1;
20875  } else {
20876  init = 0;
20877  }
20878 
20879  /* Try and load any already created modules */
20880  module_head = SWIG_GetModule(clientdata);
20881  if (!module_head) {
20882  /* This is the first module loaded for this interpreter */
20883  /* so set the swig module into the interpreter */
20884  SWIG_SetModule(clientdata, &swig_module);
20885  module_head = &swig_module;
20886  } else {
20887  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
20888  found=0;
20889  iter=module_head;
20890  do {
20891  if (iter==&swig_module) {
20892  found=1;
20893  break;
20894  }
20895  iter=iter->next;
20896  } while (iter!= module_head);
20897 
20898  /* if the is found in the list, then all is done and we may leave */
20899  if (found) return;
20900  /* otherwise we must add out module into the list */
20901  swig_module.next = module_head->next;
20902  module_head->next = &swig_module;
20903  }
20904 
20905  /* When multiple interpeters are used, a module could have already been initialized in
20906  a different interpreter, but not yet have a pointer in this interpreter.
20907  In this case, we do not want to continue adding types... everything should be
20908  set up already */
20909  if (init == 0) return;
20910 
20911  /* Now work on filling in swig_module.types */
20912 #ifdef SWIGRUNTIME_DEBUG
20913  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20914 #endif
20915  for (i = 0; i < swig_module.size; ++i) {
20916  swig_type_info *type = 0;
20917  swig_type_info *ret;
20918  swig_cast_info *cast;
20919 
20920 #ifdef SWIGRUNTIME_DEBUG
20921  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20922 #endif
20923 
20924  /* if there is another module already loaded */
20925  if (swig_module.next != &swig_module) {
20926  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20927  }
20928  if (type) {
20929  /* Overwrite clientdata field */
20930 #ifdef SWIGRUNTIME_DEBUG
20931  printf("SWIG_InitializeModule: found type %s\n", type->name);
20932 #endif
20933  if (swig_module.type_initial[i]->clientdata) {
20934  type->clientdata = swig_module.type_initial[i]->clientdata;
20935 #ifdef SWIGRUNTIME_DEBUG
20936  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20937 #endif
20938  }
20939  } else {
20940  type = swig_module.type_initial[i];
20941  }
20942 
20943  /* Insert casting types */
20944  cast = swig_module.cast_initial[i];
20945  while (cast->type) {
20946 
20947  /* Don't need to add information already in the list */
20948  ret = 0;
20949 #ifdef SWIGRUNTIME_DEBUG
20950  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20951 #endif
20952  if (swig_module.next != &swig_module) {
20953  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20954 #ifdef SWIGRUNTIME_DEBUG
20955  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20956 #endif
20957  }
20958  if (ret) {
20959  if (type == swig_module.type_initial[i]) {
20960 #ifdef SWIGRUNTIME_DEBUG
20961  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20962 #endif
20963  cast->type = ret;
20964  ret = 0;
20965  } else {
20966  /* Check for casting already in the list */
20967  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20968 #ifdef SWIGRUNTIME_DEBUG
20969  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20970 #endif
20971  if (!ocast) ret = 0;
20972  }
20973  }
20974 
20975  if (!ret) {
20976 #ifdef SWIGRUNTIME_DEBUG
20977  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20978 #endif
20979  if (type->cast) {
20980  type->cast->prev = cast;
20981  cast->next = type->cast;
20982  }
20983  type->cast = cast;
20984  }
20985  cast++;
20986  }
20987  /* Set entry in modules->types array equal to the type */
20988  swig_module.types[i] = type;
20989  }
20990  swig_module.types[i] = 0;
20991 
20992 #ifdef SWIGRUNTIME_DEBUG
20993  printf("**** SWIG_InitializeModule: Cast List ******\n");
20994  for (i = 0; i < swig_module.size; ++i) {
20995  int j = 0;
20996  swig_cast_info *cast = swig_module.cast_initial[i];
20997  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20998  while (cast->type) {
20999  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21000  cast++;
21001  ++j;
21002  }
21003  printf("---- Total casts: %d\n",j);
21004  }
21005  printf("**** SWIG_InitializeModule: Cast List ******\n");
21006 #endif
21007 }
21008 
21009 /* This function will propagate the clientdata field of type to
21010 * any new swig_type_info structures that have been added into the list
21011 * of equivalent types. It is like calling
21012 * SWIG_TypeClientData(type, clientdata) a second time.
21013 */
21014 SWIGRUNTIME void
21016  size_t i;
21017  swig_cast_info *equiv;
21018  static int init_run = 0;
21019 
21020  if (init_run) return;
21021  init_run = 1;
21022 
21023  for (i = 0; i < swig_module.size; i++) {
21024  if (swig_module.types[i]->clientdata) {
21025  equiv = swig_module.types[i]->cast;
21026  while (equiv) {
21027  if (!equiv->converter) {
21028  if (equiv->type && !equiv->type->clientdata)
21029  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21030  }
21031  equiv = equiv->next;
21032  }
21033  }
21034  }
21035 }
21036 
21037 #ifdef __cplusplus
21038 #if 0
21039 { /* c-mode */
21040 #endif
21041 }
21042 #endif
21043 
21044 
21045 
21046 static void SWIG_init_user(octave_swig_type* module_ns);
21047 
21048 SWIGINTERN void SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
21049  octave_value_list args;
21050  args.append(name);
21051  args.append(octloadfcn->fcn_file_name());
21052  feval("autoload", args, 0);
21053 }
21054 
21055 static const char *const subclass_usage = "-*- texinfo -*- \n\
21056 @deftypefn {Loadable Function} {} subclass()\n\
21057 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
21058 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
21059 \n\
21060 See the SWIG manual for usage examples.\n\
21061 @end deftypefn";
21062 
21063 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
21065  for (int j = 0; j < args.length(); ++j) {
21066  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
21067  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
21068  octave_swig_type *ost = osr->get_ptr();
21069  if (!ost->is_owned()) {
21070  error("cannot subclass object not constructed on octave side");
21071  return octave_value_list();
21072  }
21073  top->merge(*ost);
21074  } else if (args(j).is_function_handle()) {
21075  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
21076  } else if (args(j).is_string()) {
21077  if (j + 1 >= args.length()) {
21078  error("member assignments must be of string,value form");
21079  return octave_value_list();
21080  }
21081  top->assign(args(j).string_value(), args(j + 1));
21082  ++j;
21083  } else {
21084  error("invalid arguments to subclass()");
21085  return octave_value_list();
21086  }
21087  }
21088  return octave_value(Swig::swig_value_ref(top));
21089 }
21090 
21091 static const char *const swig_type_usage = "-*- texinfo -*- \n\
21092 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
21093 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
21094 @end deftypefn";
21095 
21096 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
21097  if (args.length() != 1) {
21098  error("swig_type() must be called with only a single object");
21099  return octave_value_list();
21100  }
21101  octave_swig_type *ost = Swig::swig_value_deref(args(0));
21102  if (!ost) {
21103  error("object is not a swig_ref");
21104  return octave_value_list();
21105  }
21106  return octave_value(ost->swig_type_name());
21107 }
21108 
21109 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
21110 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
21111 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
21112 otherwise return `<unknown>'.\n\
21113 @end deftypefn";
21114 
21115 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
21116  if (args.length() != 1 || !args(0).is_string()) {
21117  error("swig_typequery() must be called with single string argument");
21118  return octave_value_list();
21119  }
21120  swig_module_info *module = SWIG_GetModule(0);
21121  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
21122  if (!type)
21123  return octave_value("<unknown>");
21124  return octave_value(type->name);
21125 }
21126 
21127 static const char *const swig_this_usage = "-*- texinfo -*- \n\
21128 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
21129 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
21130 @end deftypefn";
21131 
21132 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
21133  if (args.length() != 1) {
21134  error("swig_this() must be called with only a single object");
21135  return octave_value_list();
21136  }
21137  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
21138  return octave_value(octave_uint64(0));
21139  octave_swig_type *ost = Swig::swig_value_deref(args(0));
21140  if (!ost) {
21141  error("object is not a swig_ref");
21142  return octave_value_list();
21143  }
21144  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
21145 }
21146 
21147 // workaround to prevent octave seg-faulting on exit: register at-exit
21148 // function which exits octave immediately without trying to cleanup memory.
21149 // definitely affects version 3.2.*, not sure about 3.3.*, seems to be
21150 // fixed in version 3.4.* and above. can be turned on/off with macros.
21151 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
21152 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
21153 #define SWIG_OCTAVE_SEGFAULT_HACK
21154 #endif
21155 #endif
21156 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21157 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
21158 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
21160  _exit(exit_status);
21161 }
21162 #endif
21163 
21164 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
21165 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
21166 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
21167 \n\
21168 To load the module into the global namespace:\n\
21169 @example\n\
21170 " SWIG_name_d ";\n\
21171 @end example\n\
21172 To access the module through a local variable, without loading it globally:\n\
21173 @example\n\
21174 " SWIG_name_d " = " SWIG_name_d ";\n\
21175 @end example\n\
21176 To access the module locally through a variable named, e.g. @var{modl}:\n\
21177 @example\n\
21178 @var{modl} = " SWIG_name_d ";\n\
21179 @end example\n\
21180 @end deftypefn";
21181 
21182 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
21183 
21184  static octave_swig_type* module_ns = 0;
21185  octave_value_list retval;
21186 
21187  // create module on first function call
21188  if (!module_ns) {
21189 
21190 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21192 #endif
21193 
21194  // workaround bug in octave where installing global variable of custom type and then
21195  // exiting without explicitly clearing the variable causes octave to segfault.
21196 #if OCTAVE_API_VERSION_NUMBER >= 37
21197  octave_value_list eval_args;
21198  eval_args.append("base");
21199  eval_args.append("function __swig_atexit__; "
21200  " if mislocked() "
21201  " clear -all; "
21202  " else "
21203  " mlock(); "
21204  " endif; "
21205  "endfunction; "
21206  "__swig_atexit__; "
21207  "atexit(\"__swig_atexit__\", false); "
21208  "atexit(\"__swig_atexit__\")");
21209  feval("evalin", eval_args, 0);
21210 #endif
21211 
21212  octave_swig_ref::register_type();
21213  octave_swig_packed::register_type();
21216 
21217  octave_function *me = octave_call_stack::current();
21218 
21219  SWIG_Octave_InstallFunction(me, "swig_type");
21220  SWIG_Octave_InstallFunction(me, "swig_typequery");
21221  SWIG_Octave_InstallFunction(me, "swig_this");
21222  SWIG_Octave_InstallFunction(me, "subclass");
21223 
21224  octave_swig_type* cvar_ns=0;
21225  if (std::string(SWIG_global_name) != ".") {
21226  cvar_ns=new octave_swig_type;
21227  for (int j=0;swig_globals[j].name;++j)
21228  if (swig_globals[j].get_method)
21229  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
21230  }
21231 
21232  module_ns=new octave_swig_type(0, 0, 0, true);
21233  if (std::string(SWIG_global_name) != ".") {
21234  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
21235  }
21236  else {
21237  for (int j=0;swig_globals[j].name;++j)
21238  if (swig_globals[j].get_method)
21239  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21240  }
21241  for (int j=0;swig_globals[j].name;++j)
21242  if (swig_globals[j].method)
21243  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21244 
21245  // * need better solution here; swig_type -> octave_class mapping is
21246  // * really n-to-1, in some cases such as template partial spec, etc.
21247  // * see failing tests.
21248  for (int j=0;swig_types[j];++j)
21249  if (swig_types[j]->clientdata) {
21250  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
21251  module_ns->assign(c->name,
21253  (new octave_swig_type(0,swig_types[j])));
21254  }
21255 
21256  SWIG_init_user(module_ns);
21257 
21258  SWIG_InstallOps(octave_swig_ref::static_type_id());
21259 
21260 #if OCTAVE_API_VERSION_NUMBER < 37
21261  mlock(me->name());
21262 #else
21263  mlock();
21264 #endif
21265 
21266  }
21267 
21268  // return module if asked for
21269  if (args.length() == 0 && nargout == 1) {
21270  retval = octave_value(module_ns->as_value());
21271  }
21272 
21273  // if call with not output arguments, load globally
21274  else if (args.length() == 0 && nargout == 0) {
21275 
21276  octave_function *me = octave_call_stack::current();
21277 
21279  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
21280  if (mb->second.first && mb->second.first->method) {
21281  SWIG_Octave_InstallFunction(me, mb->first);
21282  }
21283  else if (mb->second.second.is_defined()) {
21284  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
21285  SWIG_Octave_LinkGlobalValue(mb->first);
21286  }
21287  }
21288 
21289  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
21290  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
21291 
21292  }
21293 
21294  // otherwise print usage
21295  else {
21296  print_usage();
21297  }
21298 
21299  return retval;
21300 
21301 }
21302 
21303 
21304 static void SWIG_init_user(octave_swig_type* module_ns)
21305 {
21306  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
21307  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
21308  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
21309  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
21310  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
21311  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
21312  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
21313  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
21314  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
21315  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
21316  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
21317  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
21318  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
21319  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
21320  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
21321  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
21322  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
21323  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
21324  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
21325  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
21326  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
21327  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
21328  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
21329  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
21330  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int((int)(25)));
21331  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int((int)(26)));
21332  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int((int)(27)));
21333  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
21334  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
21335  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
21336  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int((int)(31)));
21337  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
21338  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
21339  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int((int)(34)));
21340  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int((int)(35)));
21341  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int((int)(36)));
21342  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int((int)(37)));
21343  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
21344  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
21345  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
21346  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
21347  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
21348  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
21349  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int((int)(1)));
21350  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int((int)(2)));
21351  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int((int)(3)));
21352  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int((int)(4)));
21353  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
21354  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
21355  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
21356  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
21357  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
21358  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
21359  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
21360  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
21361  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
21362  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
21363  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
21364  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
21365  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
21366  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
21367  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
21368  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
21369  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
21370  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
21371  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
21372  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
21373  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
21374  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
21375  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
21376  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
21377  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
21378  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
21379  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
21380  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
21381  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
21382  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
21383  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
21384  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
21385  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
21386  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
21387  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
21388  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
21389  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
21390  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
21391  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
21392  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
21393  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
21394  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
21395  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
21396  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
21397  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
21398  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
21399  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
21400  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
21401  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
21402  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
21403  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
21404  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
21405  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
21406  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
21407  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
21408  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
21409  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
21410  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
21411  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
21412  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
21413  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
21414  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
21415  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
21416  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
21417  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
21418  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
21419  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
21420  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
21421  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
21422  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
21423  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
21424  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
21425  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
21426  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
21427  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
21428  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
21429  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
21430  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
21431  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
21432  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
21433  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
21434  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
21435  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
21436  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
21437  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
21438  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
21439  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
21440  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
21441  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
21442  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
21443  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
21444  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
21445  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
21446  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
21447  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
21448  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
21449  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
21450  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
21451  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
21452  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
21453  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x001)));
21454  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x002)));
21455  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x003)));
21456  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x004)));
21457  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x008)));
21458  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x010)));
21459  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x020)));
21460  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x040)));
21461  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x080)));
21462  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
21463 }
21464