PLplot  5.9.9
 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.11
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGOCTAVE
12 #define SWIG_name_d "plplot_octave"
13 #define SWIG_name plplot_octave
14 
15 #define SWIG_global_name "cvar"
16 #define SWIG_op_prefix "op_"
17 
18 
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22  struct SwigMovePointer {
23  T *ptr;
24  SwigMovePointer(T *p) : ptr(p) { }
25  ~SwigMovePointer() { delete ptr; }
26  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27  } pointer;
28  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31  SwigValueWrapper() : pointer(0) { }
32  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33  operator T&() const { return *pointer.ptr; }
34  T *operator&() { return pointer.ptr; }
35 };
36 
37 template <typename T> T SwigValueInit() {
38  return T();
39 }
40 #endif
41 
42 /* -----------------------------------------------------------------------------
43  * This section contains generic SWIG labels for method/variable
44  * declarations/attributes, and other compiler dependent labels.
45  * ----------------------------------------------------------------------------- */
46 
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59 
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68 
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83 
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89 
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97 
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102 
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107 
108 /* exporting methods */
109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 # ifndef GCC_HASCLASSVISIBILITY
111 # define GCC_HASCLASSVISIBILITY
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 
151 
152 #include <cstdlib>
153 #include <iostream>
154 #include <octave/oct.h>
155 #include <octave/Cell.h>
156 #include <octave/dynamic-ld.h>
157 #include <octave/oct-env.h>
158 #include <octave/oct-map.h>
159 #include <octave/ov-fcn-handle.h>
160 #include <octave/parse.h>
161 #include <octave/toplev.h>
162 #include <octave/unwind-prot.h>
163 
164 /* -----------------------------------------------------------------------------
165  * swigrun.swg
166  *
167  * This file contains generic C API SWIG runtime support for pointer
168  * type checking.
169  * ----------------------------------------------------------------------------- */
170 
171 /* This should only be incremented when either the layout of swig_type_info changes,
172  or for whatever reason, the runtime changes incompatibly */
173 #define SWIG_RUNTIME_VERSION "4"
174 
175 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
176 #ifdef SWIG_TYPE_TABLE
177 # define SWIG_QUOTE_STRING(x) #x
178 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
179 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
180 #else
181 # define SWIG_TYPE_TABLE_NAME
182 #endif
183 
184 /*
185  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
186  creating a static or dynamic library from the SWIG runtime code.
187  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
188 
189  But only do this if strictly necessary, ie, if you have problems
190  with your compiler or suchlike.
191 */
192 
193 #ifndef SWIGRUNTIME
194 # define SWIGRUNTIME SWIGINTERN
195 #endif
196 
197 #ifndef SWIGRUNTIMEINLINE
198 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
199 #endif
200 
201 /* Generic buffer size */
202 #ifndef SWIG_BUFFER_SIZE
203 # define SWIG_BUFFER_SIZE 1024
204 #endif
205 
206 /* Flags for pointer conversions */
207 #define SWIG_POINTER_DISOWN 0x1
208 #define SWIG_CAST_NEW_MEMORY 0x2
209 
210 /* Flags for new pointer objects */
211 #define SWIG_POINTER_OWN 0x1
212 
213 
214 /*
215  Flags/methods for returning states.
216 
217  The SWIG conversion methods, as ConvertPtr, return an integer
218  that tells if the conversion was successful or not. And if not,
219  an error code can be returned (see swigerrors.swg for the codes).
220 
221  Use the following macros/flags to set or process the returning
222  states.
223 
224  In old versions of SWIG, code such as the following was usually written:
225 
226  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
227  // success code
228  } else {
229  //fail code
230  }
231 
232  Now you can be more explicit:
233 
234  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
235  if (SWIG_IsOK(res)) {
236  // success code
237  } else {
238  // fail code
239  }
240 
241  which is the same really, but now you can also do
242 
243  Type *ptr;
244  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
245  if (SWIG_IsOK(res)) {
246  // success code
247  if (SWIG_IsNewObj(res) {
248  ...
249  delete *ptr;
250  } else {
251  ...
252  }
253  } else {
254  // fail code
255  }
256 
257  I.e., now SWIG_ConvertPtr can return new objects and you can
258  identify the case and take care of the deallocation. Of course that
259  also requires SWIG_ConvertPtr to return new result values, such as
260 
261  int SWIG_ConvertPtr(obj, ptr,...) {
262  if (<obj is ok>) {
263  if (<need new object>) {
264  *ptr = <ptr to new allocated object>;
265  return SWIG_NEWOBJ;
266  } else {
267  *ptr = <ptr to old object>;
268  return SWIG_OLDOBJ;
269  }
270  } else {
271  return SWIG_BADOBJ;
272  }
273  }
274 
275  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
276  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
277  SWIG errors code.
278 
279  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
280  allows to return the 'cast rank', for example, if you have this
281 
282  int food(double)
283  int fooi(int);
284 
285  and you call
286 
287  food(1) // cast rank '1' (1 -> 1.0)
288  fooi(1) // cast rank '0'
289 
290  just use the SWIG_AddCast()/SWIG_CheckState()
291 */
292 
293 #define SWIG_OK (0)
294 #define SWIG_ERROR (-1)
295 #define SWIG_IsOK(r) (r >= 0)
296 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
297 
298 /* The CastRankLimit says how many bits are used for the cast rank */
299 #define SWIG_CASTRANKLIMIT (1 << 8)
300 /* The NewMask denotes the object was created (using new/malloc) */
301 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
302 /* The TmpMask is for in/out typemaps that use temporal objects */
303 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
304 /* Simple returning values */
305 #define SWIG_BADOBJ (SWIG_ERROR)
306 #define SWIG_OLDOBJ (SWIG_OK)
307 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
308 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
309 /* Check, add and del mask methods */
310 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
311 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
312 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
313 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
314 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
315 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
316 
317 /* Cast-Rank Mode */
318 #if defined(SWIG_CASTRANK_MODE)
319 # ifndef SWIG_TypeRank
320 # define SWIG_TypeRank unsigned long
321 # endif
322 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
323 # define SWIG_MAXCASTRANK (2)
324 # endif
325 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
326 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
327 SWIGINTERNINLINE int SWIG_AddCast(int r) {
328  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
329 }
331  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
332 }
333 #else /* no cast-rank mode */
334 # define SWIG_AddCast(r) (r)
335 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
336 #endif
337 
338 
339 #include <string.h>
340 
341 #ifdef __cplusplus
342 extern "C" {
343 #endif
344 
345 typedef void *(*swig_converter_func)(void *, int *);
346 typedef struct swig_type_info *(*swig_dycast_func)(void **);
347 
348 /* Structure to store information on one type */
349 typedef struct swig_type_info {
350  const char *name; /* mangled name of this type */
351  const char *str; /* human readable name of this type */
352  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
353  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
354  void *clientdata; /* language specific type data */
355  int owndata; /* flag if the structure owns the clientdata */
357 
358 /* Structure to store a type and conversion function used for casting */
359 typedef struct swig_cast_info {
360  swig_type_info *type; /* pointer to type that is equivalent to this type */
361  swig_converter_func converter; /* function to cast the void pointers */
362  struct swig_cast_info *next; /* pointer to next cast in linked list */
363  struct swig_cast_info *prev; /* pointer to the previous cast */
365 
366 /* Structure used to store module information
367  * Each module generates one structure like this, and the runtime collects
368  * all of these structures and stores them in a circularly linked list.*/
369 typedef struct swig_module_info {
370  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
371  size_t size; /* Number of types in this module */
372  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
373  swig_type_info **type_initial; /* Array of initially generated type structures */
374  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
375  void *clientdata; /* Language specific module data */
377 
378 /*
379  Compare two type names skipping the space characters, therefore
380  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
381 
382  Return 0 when the two name types are equivalent, as in
383  strncmp, but skipping ' '.
384 */
385 SWIGRUNTIME int
386 SWIG_TypeNameComp(const char *f1, const char *l1,
387  const char *f2, const char *l2) {
388  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
389  while ((*f1 == ' ') && (f1 != l1)) ++f1;
390  while ((*f2 == ' ') && (f2 != l2)) ++f2;
391  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
392  }
393  return (int)((l1 - f1) - (l2 - f2));
394 }
395 
396 /*
397  Check type equivalence in a name list like <name1>|<name2>|...
398  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
399 */
400 SWIGRUNTIME int
401 SWIG_TypeCmp(const char *nb, const char *tb) {
402  int equiv = 1;
403  const char* te = tb + strlen(tb);
404  const char* ne = nb;
405  while (equiv != 0 && *ne) {
406  for (nb = ne; *ne; ++ne) {
407  if (*ne == '|') break;
408  }
409  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
410  if (*ne) ++ne;
411  }
412  return equiv;
413 }
414 
415 /*
416  Check type equivalence in a name list like <name1>|<name2>|...
417  Return 0 if not equal, 1 if equal
418 */
419 SWIGRUNTIME int
420 SWIG_TypeEquiv(const char *nb, const char *tb) {
421  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
422 }
423 
424 /*
425  Check the typename
426 */
428 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
429  if (ty) {
430  swig_cast_info *iter = ty->cast;
431  while (iter) {
432  if (strcmp(iter->type->name, c) == 0) {
433  if (iter == ty->cast)
434  return iter;
435  /* Move iter to the top of the linked list */
436  iter->prev->next = iter->next;
437  if (iter->next)
438  iter->next->prev = iter->prev;
439  iter->next = ty->cast;
440  iter->prev = 0;
441  if (ty->cast) ty->cast->prev = iter;
442  ty->cast = iter;
443  return iter;
444  }
445  iter = iter->next;
446  }
447  }
448  return 0;
449 }
450 
451 /*
452  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
453 */
456  if (ty) {
457  swig_cast_info *iter = ty->cast;
458  while (iter) {
459  if (iter->type == from) {
460  if (iter == ty->cast)
461  return iter;
462  /* Move iter to the top of the linked list */
463  iter->prev->next = iter->next;
464  if (iter->next)
465  iter->next->prev = iter->prev;
466  iter->next = ty->cast;
467  iter->prev = 0;
468  if (ty->cast) ty->cast->prev = iter;
469  ty->cast = iter;
470  return iter;
471  }
472  iter = iter->next;
473  }
474  }
475  return 0;
476 }
477 
478 /*
479  Cast a pointer up an inheritance hierarchy
480 */
481 SWIGRUNTIMEINLINE void *
482 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
483  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
484 }
485 
486 /*
487  Dynamic pointer casting. Down an inheritance hierarchy
488 */
491  swig_type_info *lastty = ty;
492  if (!ty || !ty->dcast) return ty;
493  while (ty && (ty->dcast)) {
494  ty = (*ty->dcast)(ptr);
495  if (ty) lastty = ty;
496  }
497  return lastty;
498 }
499 
500 /*
501  Return the name associated with this type
502 */
503 SWIGRUNTIMEINLINE const char *
505  return ty->name;
506 }
507 
508 /*
509  Return the pretty name associated with this type,
510  that is an unmangled type name in a form presentable to the user.
511 */
512 SWIGRUNTIME const char *
514  /* The "str" field contains the equivalent pretty names of the
515  type, separated by vertical-bar characters. We choose
516  to print the last name, as it is often (?) the most
517  specific. */
518  if (!type) return NULL;
519  if (type->str != NULL) {
520  const char *last_name = type->str;
521  const char *s;
522  for (s = type->str; *s; s++)
523  if (*s == '|') last_name = s+1;
524  return last_name;
525  }
526  else
527  return type->name;
528 }
529 
530 /*
531  Set the clientdata field for a type
532 */
533 SWIGRUNTIME void
535  swig_cast_info *cast = ti->cast;
536  /* if (ti->clientdata == clientdata) return; */
537  ti->clientdata = clientdata;
538 
539  while (cast) {
540  if (!cast->converter) {
541  swig_type_info *tc = cast->type;
542  if (!tc->clientdata) {
543  SWIG_TypeClientData(tc, clientdata);
544  }
545  }
546  cast = cast->next;
547  }
548 }
549 SWIGRUNTIME void
551  SWIG_TypeClientData(ti, clientdata);
552  ti->owndata = 1;
553 }
554 
555 /*
556  Search for a swig_type_info structure only by mangled name
557  Search is a O(log #types)
558 
559  We start searching at module start, and finish searching when start == end.
560  Note: if start == end at the beginning of the function, we go all the way around
561  the circular list.
562 */
565  swig_module_info *end,
566  const char *name) {
567  swig_module_info *iter = start;
568  do {
569  if (iter->size) {
570  register size_t l = 0;
571  register size_t r = iter->size - 1;
572  do {
573  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
574  register size_t i = (l + r) >> 1;
575  const char *iname = iter->types[i]->name;
576  if (iname) {
577  register int compare = strcmp(name, iname);
578  if (compare == 0) {
579  return iter->types[i];
580  } else if (compare < 0) {
581  if (i) {
582  r = i - 1;
583  } else {
584  break;
585  }
586  } else if (compare > 0) {
587  l = i + 1;
588  }
589  } else {
590  break; /* should never happen */
591  }
592  } while (l <= r);
593  }
594  iter = iter->next;
595  } while (iter != end);
596  return 0;
597 }
598 
599 /*
600  Search for a swig_type_info structure for either a mangled name or a human readable name.
601  It first searches the mangled names of the types, which is a O(log #types)
602  If a type is not found it then searches the human readable names, which is O(#types).
603 
604  We start searching at module start, and finish searching when start == end.
605  Note: if start == end at the beginning of the function, we go all the way around
606  the circular list.
607 */
610  swig_module_info *end,
611  const char *name) {
612  /* STEP 1: Search the name field using binary search */
613  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
614  if (ret) {
615  return ret;
616  } else {
617  /* STEP 2: If the type hasn't been found, do a complete search
618  of the str field (the human readable name) */
619  swig_module_info *iter = start;
620  do {
621  register size_t i = 0;
622  for (; i < iter->size; ++i) {
623  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
624  return iter->types[i];
625  }
626  iter = iter->next;
627  } while (iter != end);
628  }
629 
630  /* neither found a match */
631  return 0;
632 }
633 
634 /*
635  Pack binary data into a string
636 */
637 SWIGRUNTIME char *
638 SWIG_PackData(char *c, void *ptr, size_t sz) {
639  static const char hex[17] = "0123456789abcdef";
640  register const unsigned char *u = (unsigned char *) ptr;
641  register const unsigned char *eu = u + sz;
642  for (; u != eu; ++u) {
643  register unsigned char uu = *u;
644  *(c++) = hex[(uu & 0xf0) >> 4];
645  *(c++) = hex[uu & 0xf];
646  }
647  return c;
648 }
649 
650 /*
651  Unpack binary data from a string
652 */
653 SWIGRUNTIME const char *
654 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
655  register unsigned char *u = (unsigned char *) ptr;
656  register const unsigned char *eu = u + sz;
657  for (; u != eu; ++u) {
658  register char d = *(c++);
659  register unsigned char uu;
660  if ((d >= '0') && (d <= '9'))
661  uu = ((d - '0') << 4);
662  else if ((d >= 'a') && (d <= 'f'))
663  uu = ((d - ('a'-10)) << 4);
664  else
665  return (char *) 0;
666  d = *(c++);
667  if ((d >= '0') && (d <= '9'))
668  uu |= (d - '0');
669  else if ((d >= 'a') && (d <= 'f'))
670  uu |= (d - ('a'-10));
671  else
672  return (char *) 0;
673  *u = uu;
674  }
675  return c;
676 }
677 
678 /*
679  Pack 'void *' into a string buffer.
680 */
681 SWIGRUNTIME char *
682 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
683  char *r = buff;
684  if ((2*sizeof(void *) + 2) > bsz) return 0;
685  *(r++) = '_';
686  r = SWIG_PackData(r,&ptr,sizeof(void *));
687  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
688  strcpy(r,name);
689  return buff;
690 }
691 
692 SWIGRUNTIME const char *
693 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
694  if (*c != '_') {
695  if (strcmp(c,"NULL") == 0) {
696  *ptr = (void *) 0;
697  return name;
698  } else {
699  return 0;
700  }
701  }
702  return SWIG_UnpackData(++c,ptr,sizeof(void *));
703 }
704 
705 SWIGRUNTIME char *
706 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
707  char *r = buff;
708  size_t lname = (name ? strlen(name) : 0);
709  if ((2*sz + 2 + lname) > bsz) return 0;
710  *(r++) = '_';
711  r = SWIG_PackData(r,ptr,sz);
712  if (lname) {
713  strncpy(r,name,lname+1);
714  } else {
715  *r = 0;
716  }
717  return buff;
718 }
719 
720 SWIGRUNTIME const char *
721 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
722  if (*c != '_') {
723  if (strcmp(c,"NULL") == 0) {
724  memset(ptr,0,sz);
725  return name;
726  } else {
727  return 0;
728  }
729  }
730  return SWIG_UnpackData(++c,ptr,sz);
731 }
732 
733 #ifdef __cplusplus
734 }
735 #endif
736 
737 /* Errors in SWIG */
738 #define SWIG_UnknownError -1
739 #define SWIG_IOError -2
740 #define SWIG_RuntimeError -3
741 #define SWIG_IndexError -4
742 #define SWIG_TypeError -5
743 #define SWIG_DivisionByZero -6
744 #define SWIG_OverflowError -7
745 #define SWIG_SyntaxError -8
746 #define SWIG_ValueError -9
747 #define SWIG_SystemError -10
748 #define SWIG_AttributeError -11
749 #define SWIG_MemoryError -12
750 #define SWIG_NullReferenceError -13
751 
752 
753 
754 
755 #include <octave/version.h>
756 #ifndef OCTAVE_API_VERSION_NUMBER
757 
758  // Hack to distinguish between Octave 3.2 and earlier versions before OCTAVE_API_VERSION_NUMBER existed
759  #define ComplexLU __ignore
760  #include <octave/CmplxLU.h>
761  #undef ComplexLU
762  #ifdef octave_Complex_LU_h
763  # define OCTAVE_API_VERSION_NUMBER 36
764  #else
765  # define OCTAVE_API_VERSION_NUMBER 37
766  #endif
767 
768 #endif
769 
770 #if OCTAVE_API_VERSION_NUMBER < 37
771 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
772 #else
773 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
774 #endif
775 
776 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
777  if (num_args > max_args && !varargs)
778  error("function %s takes at most %i arguments", func_name, max_args);
779  else if (num_args < min_args)
780  error("function %s requires at least %i arguments", func_name, min_args);
781  else
782  return true;
783  return false;
784 }
785 
786 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
787  ovl->append(ov);
788  return ovl;
789 }
790 
791 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
792  switch (code) {
793  case SWIG_MemoryError:
794  return "SWIG_MemoryError";
795  case SWIG_IOError:
796  return "SWIG_IOError";
797  case SWIG_RuntimeError:
798  return "SWIG_RuntimeError";
799  case SWIG_IndexError:
800  return "SWIG_IndexError";
801  case SWIG_TypeError:
802  return "SWIG_TypeError";
803  case SWIG_DivisionByZero:
804  return "SWIG_DivisionByZero";
805  case SWIG_OverflowError:
806  return "SWIG_OverflowError";
807  case SWIG_SyntaxError:
808  return "SWIG_SyntaxError";
809  case SWIG_ValueError:
810  return "SWIG_ValueError";
811  case SWIG_SystemError:
812  return "SWIG_SystemError";
813  case SWIG_AttributeError:
814  return "SWIG_AttributeError";
815  }
816  return "SWIG unknown error";
817 }
818 
819 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
820  octave_value type(SWIG_ErrorType(code));
821  std::string r = msg;
822  r += " (" + type.string_value() + ")";
823  error(r.c_str());
824  return octave_value(r);
825 }
826 
827 #define SWIG_fail goto fail
828 
829 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
830 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
831 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
832 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
833 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
834 #define swig_owntype int
835 
836 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
837 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
838 
839 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
840 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
841 
842 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
843 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
844 
845 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
846 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
847 #define SWIG_MODULE_CLIENTDATA_TYPE void*
848 
849 #define Octave_Error_Occurred() 0
850 #define SWIG_Octave_AddErrorMsg(msg) {;}
851 
854 
855 // For backward compatibility only
856 #define SWIG_POINTER_EXCEPTION 0
857 #define SWIG_arg_fail(arg) 0
858 
859 // Runtime API implementation
860 
861 #include <map>
862 #include <vector>
863 #include <string>
864 
865 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
866 class octave_swig_type;
867 
868 namespace Swig {
869 
870 #ifdef SWIG_DIRECTORS
871 
872  class Director;
873 
874  typedef std::map < void *, Director * > rtdir_map;
875  SWIGINTERN rtdir_map* get_rtdir_map();
876  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
877  SWIGINTERNINLINE void erase_rtdir(void *vptr);
878  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
879 
880  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
881  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
882  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
883 
884 #endif
885 
886  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
888  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
889 }
890 
891 #ifdef SWIG_DIRECTORS
892 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
893 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
894 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
895 #endif
896 
898  const char *name;
902  int flags; // 1 static, 2 global
903  const char *doc;
904  bool is_static() const {
905  return flags &1;
906  } bool is_global() const {
907  return flags &2;
908  }
909  };
910 
912  const char *name;
914  int director;
916  const char *constructor_doc;
919  const char **base_names;
921  };
922 
923  // octave_swig_type plays the role of both the shadow class and the class
924  // representation within Octave, since there is no support for classes.
925  //
926  // These should really be decoupled, with the class support added to Octave
927  // and the shadow class given by an m-file script. That would dramatically
928  // reduce the runtime complexity, and be more in line w/ other modules.
929 
930  class octave_swig_type:public octave_base_value {
931  struct cpp_ptr {
932  void *ptr;
933  bool destroyed;
934  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
935  }};
936  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
937 
939 
940  const swig_type_info *construct_type; // type of special type object
941  std::vector < type_ptr_pair > types; // our c++ base classes
942  int own; // whether we call c++ destructors when we die
943 
944  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
945  typedef std::map < std::string, member_value_pair > member_map;
948 
949  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
950  if (!type->clientdata)
951  return 0;
953  const swig_octave_member *m;
954  for (m = c->members; m->name; ++m)
955  if (m->name == name)
956  return m;
957  for (int j = 0; c->base_names[j]; ++j) {
958  if (!c->base[j]) {
959  if (!module)
960  module = SWIG_GetModule(0);
961  assert(module);
963  }
964  if (!c->base[j])
965  return 0;
966  if ((m = find_member(c->base[j], name)))
967  return m;
968  }
969  return 0;
970  }
971 
972  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
973  member_map::iterator it = members.find(name);
974  if (it != members.end())
975  return &it->second;
976  const swig_octave_member *m;
977  for (unsigned int j = 0; j < types.size(); ++j)
978  if ((m = find_member(types[j].first, name)))
979  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
980  if (!insert_if_not_found)
981  return 0;
982  return &members[name];
983  }
984 
985  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
986  if (!base) {
987  for (unsigned int j = 0; j < types.size(); ++j) {
988  assert(types[j].first->clientdata);
989  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
990  if (cj->name == name)
991  return types[j].first;
992  }
993  return 0;
994  }
995  assert(base->clientdata);
997  for (int j = 0; c->base_names[j]; ++j) {
998  if (!c->base[j]) {
999  if (!module)
1000  module = SWIG_GetModule(0);
1001  assert(module);
1003  }
1004  if (!c->base[j])
1005  return 0;
1006  assert(c->base[j]->clientdata);
1008  if (cj->name == name)
1009  return c->base[j];
1010  }
1011  return 0;
1012  }
1013 
1014  void load_members(const swig_octave_class* c,member_map& out) const {
1015  for (const swig_octave_member *m = c->members; m->name; ++m) {
1016  if (out.find(m->name) == out.end())
1017  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1018  }
1019  for (int j = 0; c->base_names[j]; ++j) {
1020  if (!c->base[j]) {
1021  if (!module)
1022  module = SWIG_GetModule(0);
1023  assert(module);
1025  }
1026  if (!c->base[j])
1027  continue;
1028  assert(c->base[j]->clientdata);
1029  const swig_octave_class *cj =
1030  (const swig_octave_class *) c->base[j]->clientdata;
1031  load_members(cj,out);
1032  }
1033  }
1034 
1035  void load_members(member_map& out) const {
1036  out=members;
1037  for (unsigned int j = 0; j < types.size(); ++j)
1038  if (types[j].first->clientdata)
1039  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1040  }
1041 
1042  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1043  if (m->second.is_defined())
1044  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1045  else if (m->first && m->first->method)
1046  return m->first->method(args, nargout);
1047  error("member not defined or not invocable");
1048  return octave_value_list();
1049  }
1050 
1051  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
1052  member_value_pair *m = find_member(symbol, false);
1053  if (!m || m->first->is_static() || m->first->is_global())
1054  return false;
1055  octave_value_list args;
1056  args.append(as_value());
1057  octave_value_list argout(member_invoke(m, args, 1));
1058  if (argout.length() < 1)
1059  return false;
1060  ret = argout(0);
1061  return true;
1062  }
1063 
1064  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
1065  member_value_pair *m = find_member(symbol, false);
1066  if (!m || m->first->is_static() || m->first->is_global())
1067  return false;
1068  octave_value_list args;
1069  args.append(as_value());
1070  args.append(make_value_hack(rhs));
1071  octave_value_list argout(member_invoke(m, args, 1));
1072  if (argout.length() < 1)
1073  return false;
1074  ret = argout(0);
1075  return true;
1076  }
1077 
1078  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
1079  member_value_pair *m = find_member(symbol, false);
1080  if (!m || m->first->is_static() || m->first->is_global())
1081  return false;
1082  octave_value_list args;
1083  args.append(as_value());
1084  args.append(rhs);
1085  octave_value_list argout(member_invoke(m, args, 1));
1086  if (argout.length() >= 1)
1087  ret = argout(0);
1088  return true;
1089  }
1090 
1091  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1092  if (m->second.is_defined())
1093  return m->second;
1094  else if (m->first) {
1095  if (m->first->get_method)
1096  return m->first->get_method(args, 1);
1097  else if (m->first->method)
1098  return octave_value(new octave_builtin(m->first->method));
1099  }
1100  error("undefined member");
1101  return octave_value_list();
1102  }
1103 
1104  static octave_value make_value_hack(const octave_base_value &x) {
1105  ((octave_swig_type &) x).count++;
1106  return octave_value((octave_base_value *) &x);
1107  }
1108 
1111  public:
1112 
1113  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1114  bool _always_static = false)
1115  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1116  always_static(_always_static) {
1117  if (_type || _ptr)
1118  types.push_back(std::make_pair(_type, _ptr));
1119 #ifdef SWIG_DIRECTORS
1120  if (_ptr) {
1121  Swig::Director *d = Swig::get_rtdir(_ptr);
1122  if (d)
1123  Swig::swig_director_set_self(d, this);
1124  }
1125 #endif
1126  }
1127 
1129  if (own) {
1130  ++count;
1131  for (unsigned int j = 0; j < types.size(); ++j) {
1132  if (!types[j].first || !types[j].first->clientdata)
1133  continue;
1134  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1135  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1136  c->destructor(as_value(), 0);
1137  }
1138  }
1139  }
1140 #ifdef SWIG_DIRECTORS
1141  for (unsigned int j = 0; j < types.size(); ++j)
1142  Swig::erase_rtdir(types[j].second.ptr);
1143 #endif
1144  }
1145 
1146  dim_vector dims(void) const {
1147  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1148 
1149  // Find the __dims__ method of this object
1150  member_value_pair *m = nc_this->find_member("__dims__", false);
1151 
1152  if (!m) return dim_vector(1,1);
1153 
1154  // Call the __dims__ method of this object
1155  octave_value_list inarg;
1156  inarg.append(nc_this->as_value());
1157  octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
1158 
1159  // __dims__ should return (at least) one output argument
1160  if (outarg.length() < 1) return dim_vector(1,1);
1161 
1162  octave_value & out = outarg(0);
1163 
1164  // Return value should be cell or matrix of integers
1165  if (out.is_cell()) {
1166  const Cell & c=out.cell_value();
1167  int ndim = c.rows();
1168  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1169 
1170  dim_vector d;
1171  d.resize(ndim < 2 ? 2 : ndim);
1172  d(0) = d(1) = 1;
1173 
1174  // Fill in dim_vector
1175  for (int k=0;k<ndim;k++) {
1176  const octave_value& obj = c(k);
1177  d.elem(k) = obj.int_value();
1178 
1179  // __dims__ should return a cell filled with integers
1180  if (error_state) return dim_vector(1,1);
1181  }
1182  return d;
1183  } else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1184  if (out.rows()==1 || out.columns()==1) {
1185  Array<int> a = out.int_vector_value();
1186  if (error_state) return dim_vector(1,1);
1187  dim_vector d;
1188  d.resize(a.numel() < 2 ? 2 : a.numel());
1189  d(0) = d(1) = 1;
1190  for (int k=0;k<a.numel();k++) {
1191  d.elem(k) = a(k);
1192  }
1193  return d;
1194  } else {
1195  return dim_vector(1,1);
1196  }
1197  } else {
1198  return dim_vector(1,1);
1199  }
1200  }
1201 
1202  octave_value as_value() {
1203  ++count;
1204  return Swig::swig_value_ref(this);
1205  }
1206 
1207  void incref() {
1208  ++count;
1209  }
1210 
1211  void decref() {
1212  if (!--count)
1213  delete this;
1214  }
1215 
1216  long swig_this() const {
1217  if (!types.size())
1218  return (long) this;
1219  return (long) types[0].second.ptr;
1220  }
1221  const char* help_text() const {
1222  if (!types.size())
1223  return 0;
1224  if (!types[0].first->clientdata)
1225  return 0;
1226  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1227  return c->constructor_doc;
1228  }
1229 
1230  std::string swig_type_name() const {
1231  // * need some way to manually name subclasses.
1232  // * eg optional first arg to subclass(), or named_subclass()
1233  std::string ret;
1234  for (unsigned int j = 0; j < types.size(); ++j) {
1235  if (j)
1236  ret += "_";
1237  if (types[j].first->clientdata) {
1238  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1239  ret += c->name;
1240  } else
1241  ret += types[j].first->name;
1242  }
1243  return ret;
1244  }
1245 
1247  rhs.own = 0;
1248  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1249  assert(!rhs.types[j].second.destroyed);
1250 #ifdef SWIG_DIRECTORS
1251  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1252  if (d)
1253  Swig::swig_director_set_self(d, this);
1254 #endif
1255  }
1256  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1257  members.insert(rhs.members.begin(), rhs.members.end());
1258  rhs.types.clear();
1259  rhs.members.clear();
1260  }
1261 
1262  typedef member_map::const_iterator swig_member_const_iterator;
1265 
1266  void *cast(swig_type_info *type, int *_own, int flags) {
1267  if (_own)
1268  *_own = own;
1269  if (flags &SWIG_POINTER_DISOWN)
1270  own = 0;
1271  if (!type && types.size())
1272  return types[0].second.ptr;
1273  for (unsigned int j = 0; j < types.size(); ++j)
1274  if (type == types[j].first)
1275  return types[j].second.ptr;
1276  for (unsigned int j = 0; j < types.size(); ++j) {
1277  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1278  if (!tc)
1279  continue;
1280  int newmemory = 0;
1281  void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1282  assert(!newmemory); // newmemory handling not yet implemented
1283  return vptr;
1284  }
1285  return 0;
1286  }
1287 
1288  bool is_owned() const {
1289  return own;
1290  }
1291 
1292 #ifdef SWIG_DIRECTORS
1293  void director_destroyed(Swig::Director *d) {
1294  bool found = false;
1295  for (unsigned int j = 0; j < types.size(); ++j) {
1296  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1297  if (dj == d) {
1298  types[j].second.destroyed = true;
1299  found = true;
1300  }
1301  }
1302  assert(found);
1303  }
1304 #endif
1305 
1306  void assign(const std::string &name, const octave_value &ov) {
1307  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1308  }
1309 
1310  void assign(const std::string &name, const swig_octave_member *m) {
1311  members[name] = std::make_pair(m, octave_value());
1312  }
1313 
1314  octave_base_value *clone() const {
1315  // pass-by-value is probably not desired, and is harder;
1316  // requires calling copy constructors of contained types etc.
1317  assert(0);
1318  *(int *) 0 = 0;
1319  return 0;
1320  }
1321 
1322  octave_base_value *empty_clone() const {
1323  return new octave_swig_type();
1324  }
1325 
1326  bool is_defined() const {
1327  return true;
1328  }
1329 
1330  virtual bool is_map() const {
1331  return true;
1332  }
1333 
1334  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1335  octave_value_list ovl = subsref(ops, idx, 1);
1336  return ovl.length()? ovl(0) : octave_value();
1337  }
1338 
1339  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1340  assert(ops.size() > 0);
1341  assert(ops.size() == idx.size());
1342 
1343  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1344  int skip = 0;
1345  octave_value_list sub_ovl;
1346 
1347  // constructor invocation
1348  if (ops[skip] == '(' && construct_type) {
1349  assert(construct_type->clientdata);
1351  if (!c->constructor) {
1352  error("cannot create instance");
1353  return octave_value_list();
1354  }
1355  octave_value_list args;
1356  if (c->director)
1357  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1358  args.append(*idx_it++);
1359  ++skip;
1360  sub_ovl = c->constructor(args, nargout);
1361  }
1362  // member dereference or invocation
1363  else if (ops[skip] == '.') {
1364  std::string subname;
1365  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1366  for (;;) {
1367  octave_value_list subname_ovl(*idx_it++);
1368  ++skip;
1369  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1370  subname = subname_ovl(0).string_value();
1371 
1372  const swig_type_info *next_base = find_base(subname, base);
1373  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1374  break;
1375  base = next_base;
1376  }
1377 
1378  member_value_pair tmp, *m = &tmp;
1379  if (!base || !(m->first = find_member(base, subname)))
1380  m = find_member(subname, false);
1381  if (!m) {
1382  error("member not found");
1383  return octave_value_list();
1384  }
1385 
1386  octave_value_list args;
1387  if (!always_static &&
1388  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1389  args.append(as_value());
1390  if (skip < (int) ops.size() && ops[skip] == '(' &&
1391  ((m->first && m->first->method) || m->second.is_function() ||
1392  m->second.is_function_handle())) {
1393  args.append(*idx_it++);
1394  ++skip;
1395  sub_ovl = member_invoke(m, args, nargout);
1396  } else {
1397  sub_ovl = member_deref(m, args);
1398  }
1399  }
1400  // index operator
1401  else {
1402  if (ops[skip] == '(' || ops[skip] == '{') {
1403  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1404  octave_value_list args;
1405  args.append(*idx_it++);
1406  ++skip;
1407  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1408  error("error evaluating index operator");
1409  return octave_value_list();
1410  }
1411  } else {
1412  error("unsupported subsref");
1413  return octave_value_list();
1414  }
1415  }
1416 
1417  if (skip >= (int) ops.size())
1418  return sub_ovl;
1419  if (sub_ovl.length() < 1) {
1420  error("bad subs ref");
1421  return octave_value_list();
1422  }
1423  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1424  }
1425 
1426  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1427  assert(ops.size() > 0);
1428  assert(ops.size() == idx.size());
1429 
1430  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1431  int skip = 0;
1432 
1433  if (ops.size() > 1) {
1434  std::list < octave_value_list >::const_iterator last = idx.end();
1435  --last;
1436  std::list < octave_value_list > next_idx(idx.begin(), last);
1437  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1438  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1439  }
1440 
1441  else if (ops[skip] == '(' || ops[skip] == '{') {
1442  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1443  member_value_pair *m = find_member(op_name, false);
1444  if (m) {
1445  octave_value_list args;
1446  args.append(as_value());
1447  args.append(*idx_it);
1448  args.append(rhs);
1449  member_invoke(m, args, 1);
1450  } else
1451  error("%s member not found", op_name);
1452  }
1453 
1454  else if (ops[skip] == '.') {
1455  octave_value_list subname_ovl(*idx_it++);
1456  ++skip;
1457  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1458  std::string subname = subname_ovl(0).string_value();
1459 
1460  member_value_pair *m = find_member(subname, true);
1461  if (!m->first || !m->first->set_method) {
1462  m->first = 0;
1463  m->second = rhs;
1464  } else if (m->first->set_method) {
1465  octave_value_list args;
1466  if (!m->first->is_static() && !m->first->is_global())
1467  args.append(as_value());
1468  args.append(rhs);
1469  m->first->set_method(args, 1);
1470  } else
1471  error("member not assignable");
1472  } else
1473  error("unsupported subsasgn");
1474 
1475  return as_value();
1476  }
1477 
1478  virtual bool is_object() const {
1479  return true;
1480  }
1481 
1482  virtual bool is_string() const {
1483  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1484  return !!nc_this->find_member("__str__", false);
1485  }
1486 
1487  virtual std::string string_value(bool force = false) const {
1488  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1489  member_value_pair *m = nc_this->find_member("__str__", false);
1490  if (!m) {
1491  error("__str__ method not defined");
1492  return std::string();
1493  }
1494  octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
1495  if (outarg.length() < 1 || !outarg(0).is_string()) {
1496  error("__str__ method did not return a string");
1497  return std::string();
1498  }
1499  return outarg(0).string_value();
1500  }
1501 
1502 #if OCTAVE_API_VERSION_NUMBER >= 40
1503  virtual octave_map map_value() const {
1504  return octave_map();
1505  }
1506 #else
1507  virtual Octave_map map_value() const {
1508  return Octave_map();
1509  }
1510 #endif
1511 
1512  virtual string_vector map_keys() const {
1513  member_map tmp;
1514  load_members(tmp);
1515 
1516  string_vector keys(tmp.size());
1517  int k = 0;
1518  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1519  keys(k++) = it->first;
1520 
1521  return keys;
1522  }
1523 
1524  virtual bool save_ascii (std::ostream& os) {
1525  return true;
1526  }
1527 
1528  virtual bool load_ascii (std::istream& is) {
1529  return true;
1530  }
1531 
1532  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1533  return true;
1534  }
1535 
1536  virtual bool load_binary (std::istream& is, bool swap,
1537  oct_mach_info::float_format fmt) {
1538  return true;
1539  }
1540 
1541 #if defined (HAVE_HDF5)
1542  virtual bool
1543  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1544  return true;
1545  }
1546 
1547  virtual bool
1548  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1549  return true;
1550  }
1551 #endif
1552 
1553  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1554  return string_value();
1555  }
1556 
1557  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1558  return string_value();
1559  }
1560 
1561  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1562  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1563  // (rather than any module namespace).
1564 
1565  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1566  if (!fcn)
1567  return false;
1568  ret = fcn->do_multi_index_op(1, args)(0);
1569  return true;
1570  }
1571 
1572  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1574  assert(ost);
1575 
1576  octave_value ret;
1577  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1578  return ret;
1579  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1580  octave_value_list args;
1581  args.append(make_value_hack(x));
1582  if (dispatch_global_op(symbol, args, ret))
1583  return ret;
1584 
1585  error("could not dispatch unary operator");
1586  return octave_value();
1587  }
1588 
1589  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1590  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1591  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1592 
1593  octave_value ret;
1594  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1595  return ret;
1596  if (rhs_ost) {
1597  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1598  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1599  return ret;
1600  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1601  return ret;
1602  }
1603  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1604  return ret;
1605  }
1606 
1607  std::string symbol;
1608  octave_value_list args;
1609  args.append(make_value_hack(lhs));
1610  args.append(make_value_hack(rhs));
1611 
1612  symbol = SWIG_op_prefix;
1613  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1614  symbol += "_";
1615  symbol += op_name;
1616  symbol += "_";
1617  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1618  if (dispatch_global_op(symbol, args, ret))
1619  return ret;
1620 
1621  symbol = SWIG_op_prefix;
1622  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1623  symbol += "_";
1624  symbol += op_name;
1625  symbol += "_";
1626  symbol += "any";
1627  if (dispatch_global_op(symbol, args, ret))
1628  return ret;
1629 
1630  symbol = SWIG_op_prefix;
1631  symbol += "any";
1632  symbol += "_";
1633  symbol += op_name;
1634  symbol += "_";
1635  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1636  if (dispatch_global_op(symbol, args, ret))
1637  return ret;
1638 
1639  error("could not dispatch binary operator");
1640  return octave_value();
1641  }
1642 
1643  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1644  if (is_string()) {
1645  os << string_value();
1646  return;
1647  }
1648 
1649  member_map tmp;
1650  load_members(tmp);
1651 
1652  indent(os);
1653  os << "{"; newline(os);
1654  increment_indent_level();
1655  for (unsigned int j = 0; j < types.size(); ++j) {
1656  indent(os);
1657  if (types[j].first->clientdata) {
1658  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1659  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1660  } else {
1661  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1662  }
1663  }
1664  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1665  indent(os);
1666  if (it->second.first) {
1667  const char *objtype = it->second.first->method ? "method" : "variable";
1668  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1669  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1670  assert(it->second.first->name == it->first);
1671  } else {
1672  os << it->first; newline(os);
1673  }
1674  }
1675  decrement_indent_level();
1676  indent(os);
1677  os << "}"; newline(os);
1678  }
1679  };
1680 
1681  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1682  // will call clone() via make_unique() if there is more than one outstanding
1683  // reference to the lhs, and forces the clone's reference count to 1
1684  // (so you can't just increment your own count and return this).
1685  //
1686  // One way to fix this (without modifying Octave) is to add a level of
1687  // indirection such that clone copies ref-counted pointer and we keep
1688  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1689  //
1690  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1691  // might be nice.
1692 
1693  class octave_swig_ref:public octave_base_value {
1695  public:
1697  :ptr(_ptr) { }
1698 
1700  { if (ptr) ptr->decref(); }
1701 
1703  { return ptr; }
1704 
1705  octave_base_value *clone() const
1706  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1707 
1708  octave_base_value *empty_clone() const
1709  { return new octave_swig_ref(0); }
1710 
1711  dim_vector dims(void) const
1712  { return ptr->dims(); }
1713 
1714  bool is_defined() const
1715  { return ptr->is_defined(); }
1716 
1717  virtual bool is_map() const
1718  { return ptr->is_map(); }
1719 
1720  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1721  { return ptr->subsref(ops, idx); }
1722 
1723  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1724  { return ptr->subsref(ops, idx, nargout); }
1725 
1726  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1727  { return ptr->subsasgn(ops, idx, rhs); }
1728 
1729  virtual bool is_object() const
1730  { return ptr->is_object(); }
1731 
1732  virtual bool is_string() const
1733  { return ptr->is_string(); }
1734 
1735  virtual std::string string_value(bool force = false) const
1736  { return ptr->string_value(force); }
1737 
1738 #if OCTAVE_API_VERSION_NUMBER >= 40
1739  virtual octave_map map_value() const
1740  { return ptr->map_value(); }
1741 #else
1742  virtual Octave_map map_value() const
1743  { return ptr->map_value(); }
1744 #endif
1745 
1746  virtual string_vector map_keys() const
1747  { return ptr->map_keys(); }
1748 
1749  virtual bool save_ascii (std::ostream& os)
1750  { return ptr->save_ascii(os); }
1751 
1752  virtual bool load_ascii (std::istream& is)
1753  { return ptr->load_ascii(is); }
1754 
1755  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
1756  { return ptr->save_binary(os, save_as_floats); }
1757 
1758  virtual bool load_binary (std::istream& is, bool swap,
1759  oct_mach_info::float_format fmt)
1760  { return ptr->load_binary(is, swap, fmt); }
1761 
1762 #if defined (HAVE_HDF5)
1763  virtual bool
1764  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
1765  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
1766 
1767  virtual bool
1768  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
1769  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1770 #endif
1771 
1772  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
1773  { return ptr->convert_to_str(pad, force, type); }
1774 
1775  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
1776  { return ptr->convert_to_str_internal(pad, force, type); }
1777 
1778  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1779  { return ptr->print(os, pr_as_read_syntax); }
1780 
1781  private:
1784  };
1786  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
1787 
1788  class octave_swig_packed:public octave_base_value {
1790  std::vector < char > buf;
1791  public:
1792 
1793  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
1794  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1795  }
1796 
1797  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
1798  if (outtype && outtype != type)
1799  return false;
1800  assert(sz <= buf.size());
1801  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
1802  return true;
1803  }
1804 
1805  octave_base_value *clone() const {
1806  return new octave_swig_packed(*this);
1807  }
1808 
1809  octave_base_value *empty_clone() const {
1810  return new octave_swig_packed();
1811  }
1812 
1813  bool is_defined() const {
1814  return true;
1815  }
1816 
1817  void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1818  indent(os);
1819  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
1820  }
1821 
1822 
1823  virtual bool save_ascii (std::ostream& os) {
1824  return true;
1825  }
1826 
1827  virtual bool load_ascii (std::istream& is) {
1828  return true;
1829  }
1830 
1831  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1832  return true;
1833  }
1834 
1835  virtual bool load_binary (std::istream& is, bool swap,
1836  oct_mach_info::float_format fmt) {
1837  return true;
1838  }
1839 
1840 #if defined (HAVE_HDF5)
1841  virtual bool
1842  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1843  return true;
1844  }
1845 
1846  virtual bool
1847  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1848  return true;
1849  }
1850 #endif
1851 
1852  private:
1855  };
1857  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
1858 
1859  static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
1860  error("attempt to set immutable member variable");
1861  return octave_value_list();
1862  }
1863 
1865  const octave_value_list &ovl;
1866  int j;
1867 
1868  octave_value_ref(const octave_value_list &_ovl, int _j)
1869  :ovl(_ovl), j(_j) { }
1870 
1871  operator octave_value() const {
1872  return ovl(j);
1873  }
1874 
1875  octave_value operator*() const {
1876  return ovl(j);
1877  }
1878  };
1879 
1880 
1881 namespace Swig {
1882 
1883  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
1884  return new octave_swig_ref(ost);
1885  }
1886 
1888  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1889  ov = ov.cell_value()(0);
1890  return swig_value_deref(*ov.internal_rep());
1891  }
1892 
1893  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
1894  if (ov.type_id() != octave_swig_ref::static_type_id())
1895  return 0;
1896  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
1897  return osr->get_ptr();
1898  }
1899 
1900 }
1901 
1902 
1903 #define swig_unary_op(name) \
1904 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1905  return octave_swig_type::dispatch_unary_op(x,#name); \
1906 }
1907 #define swig_binary_op(name) \
1908 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1909  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1910 }
1911 #define swigreg_unary_op(name) \
1912 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1913 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1914 #define swigreg_binary_op(name) \
1915 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1916 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1917 
1918  swig_unary_op(not);
1919  swig_unary_op(uplus);
1920  swig_unary_op(uminus);
1921  swig_unary_op(transpose);
1922  swig_unary_op(hermitian);
1923  swig_unary_op(incr);
1924  swig_unary_op(decr);
1925 
1926  swig_binary_op(add);
1927  swig_binary_op(sub);
1928  swig_binary_op(mul);
1929  swig_binary_op(div);
1930  swig_binary_op(pow);
1931  swig_binary_op(ldiv);
1932  swig_binary_op(lshift);
1933  swig_binary_op(rshift);
1934  swig_binary_op(lt);
1935  swig_binary_op(le);
1936  swig_binary_op(eq);
1937  swig_binary_op(ge);
1938  swig_binary_op(gt);
1939  swig_binary_op(ne);
1940  swig_binary_op(el_mul);
1941  swig_binary_op(el_div);
1942  swig_binary_op(el_pow);
1943  swig_binary_op(el_ldiv);
1944  swig_binary_op(el_and);
1945  swig_binary_op(el_or);
1946 
1949  swigreg_unary_op(uplus);
1950  swigreg_unary_op(uminus);
1951  swigreg_unary_op(transpose);
1952  swigreg_unary_op(hermitian);
1953  swigreg_unary_op(incr);
1954  swigreg_unary_op(decr);
1955  }
1956  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
1957  swigreg_binary_op(add);
1958  swigreg_binary_op(sub);
1959  swigreg_binary_op(mul);
1960  swigreg_binary_op(div);
1961  swigreg_binary_op(pow);
1962  swigreg_binary_op(ldiv);
1963  swigreg_binary_op(lshift);
1964  swigreg_binary_op(rshift);
1965  swigreg_binary_op(lt);
1966  swigreg_binary_op(le);
1967  swigreg_binary_op(eq);
1968  swigreg_binary_op(ge);
1969  swigreg_binary_op(gt);
1970  swigreg_binary_op(ne);
1971  swigreg_binary_op(el_mul);
1972  swigreg_binary_op(el_div);
1973  swigreg_binary_op(el_pow);
1974  swigreg_binary_op(el_ldiv);
1975  swigreg_binary_op(el_and);
1976  swigreg_binary_op(el_or);
1977  }
1979  // here we assume that tid are conseq integers increasing from zero, and
1980  // that our tid is the last one. might be better to have explicit string
1981  // list of types we should bind to, and use lookup_type to resolve their tid.
1982 
1983  SWIG_InstallUnaryOps(tid);
1984  SWIG_InstallBinaryOps(tid, tid);
1985  for (int j = 0; j < tid; ++j) {
1986  SWIG_InstallBinaryOps(j, tid);
1987  SWIG_InstallBinaryOps(tid, j);
1988  }
1989  }
1990 
1991 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1992  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
1993 
1994 #ifdef SWIG_DIRECTORS
1995  Swig::Director *d = Swig::get_rtdir(ptr);
1996  if (d && Swig::swig_director_get_self(d))
1997  return Swig::swig_director_get_self(d)->as_value();
1998 #endif
1999  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2000 }
2001 
2002 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2003  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2004  ov = ov.cell_value()(0);
2005  if (!ov.is_defined() ||
2006  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2007  if (ptr)
2008  *ptr = 0;
2009  return SWIG_OK;
2010  }
2011  if (ov.type_id() != octave_swig_ref::static_type_id())
2012  return SWIG_ERROR;
2013  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2014  octave_swig_type *ost = osr->get_ptr();
2015  void *vptr = ost->cast(type, own, flags);
2016  if (!vptr)
2017  return SWIG_ERROR;
2018  if (ptr)
2019  *ptr = vptr;
2020  return SWIG_OK;
2021 }
2022 
2023 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2024  return new octave_swig_packed(type, (char *) ptr, sz);
2025 }
2026 
2027 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2028  if (!ov.is_defined())
2029  return SWIG_ERROR;
2030  if (ov.type_id() != octave_swig_packed::static_type_id())
2031  return SWIG_ERROR;
2032  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2033  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2034 }
2035 
2036 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2037  module_ns->assign(name, ov);
2038 }
2039 
2040 SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
2041  return get_global_value(name, true);
2042 }
2043 
2044 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2045  set_global_value(name, value);
2046 }
2047 
2049 #if OCTAVE_API_VERSION_NUMBER < 37
2050  link_to_global_variable(curr_sym_tab->lookup(name, true));
2051 #else
2052  symbol_table::varref(name);
2053  symbol_table::mark_global(name);
2054 #endif
2055 }
2056 
2058  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2059  if (!ov.is_defined() ||
2060  ov.type_id() != octave_swig_packed::static_type_id())
2061  return 0;
2062  const octave_swig_packed* osp =
2063  static_cast < const octave_swig_packed *> (ov.internal_rep());
2064  swig_module_info *pointer = 0;
2065  osp->copy(0, &pointer, sizeof(swig_module_info *));
2066  return pointer;
2067 }
2068 
2069 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2070  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2072 }
2073 
2074 
2075 
2076 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2077 
2078 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2079 
2080 
2081 
2082 /* -------- TYPES TABLE (BEGIN) -------- */
2083 
2084 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2085 #define SWIGTYPE_p_char swig_types[1]
2086 #define SWIGTYPE_p_double swig_types[2]
2087 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2088 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2089 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2090 #define SWIGTYPE_p_int swig_types[6]
2091 #define SWIGTYPE_p_p_char swig_types[7]
2092 #define SWIGTYPE_p_unsigned_int swig_types[8]
2094 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2095 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2096 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2097 
2098 /* -------- TYPES TABLE (END) -------- */
2099 
2100 
2101 #define SWIGVERSION 0x020011
2102 #define SWIG_VERSION SWIGVERSION
2103 
2104 
2105 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2106 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2107 
2108 
2109 #include <stdexcept>
2110 
2111 
2112 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2113 #undef PACKAGE
2114 #undef VERSION
2115 
2116 #include "plplotP.h"
2117 
2118 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2119 #ifdef OCTAVE_EXPORT
2120  #if defined ( __GNUC__ ) && __GNUC__ > 3
2121  #undef OCTAVE_EXPORT
2122  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2123  #endif
2124 #endif
2125 
2126 
2127 
2128 // I hate global variables but this is the best way I can think of
2129 // to manage consistency checking among function arguments.
2130  static PLINT Alen = 0;
2131  static PLINT Xlen = 0, Ylen = 0;
2132 
2133 
2134 // Convenience functions copied from matwrap-based approach (currently
2135 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2136 // tricky scalar case and also adopted so that the resulting
2137 // swig-generated source code will look similar to the matwrap-generated
2138 // source code.
2139 
2140  inline int max( int a, int b )
2141  {
2142  return a >= b ? a : b;
2143  }
2144  inline int min( int a, int b )
2145  {
2146  return a >= b ? a : b;
2147  }
2148 
2149 //
2150 // Function to get the total length (rows*columns) of an octave object of
2151 // arbitrary type.
2152 // Arguments:
2153 // 1) The octave object.
2154 //
2155 // If the object is a scalar, the array length is 1.
2156 //
2157  static int
2158  _arraylen( const octave_value &o_obj )
2159  {
2160  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2161  // max is necessary because sometimes
2162  // rows() or columns() return -1 or 0 for
2163  // scalars.
2164  }
2165 
2166 //
2167 // Function to get the number of dimensions of an object.
2168 //
2169  static int
2170  _n_dims( const octave_value &o_obj )
2171  {
2172  if ( max( o_obj.columns(), 1 ) > 1 )
2173  return 2;
2174  // max is necessary because sometimes
2175  // rows() or columns() return -1 or 0 for
2176  // scalars.
2177  else if ( max( o_obj.rows(), 1 ) > 1 )
2178  return 1;
2179  else
2180  return 0;
2181  }
2182 
2183 //
2184 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2185 //
2186  static inline int
2187  _dim( const octave_value &o_obj, int dim_idx )
2188  {
2189  if ( dim_idx == 0 )
2190  return max( o_obj.rows(), 0 );
2191  // max is necessary because sometimes
2192  // rows() or columns() return -1 or 0 for
2193  // scalars.
2194  else if ( dim_idx == 1 )
2195  return max( o_obj.columns(), 0 );
2196  else
2197  return 1;
2198  }
2199 
2200 //
2201 // The following function converts an array of doubles into some other
2202 // numeric type. Arguments:
2203 // 1) Where to store the result. The type is determined from the type of
2204 // this pointer.
2205 // 2) A vector of doubles to convert.
2206 // 3) The number of doubles.
2207 //
2208  template <class FLOAT>
2209  static inline void
2210  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2211  {
2212  while ( n_el-- > 0 )
2213  *out_arr++ = (FLOAT) ( *in_arr++ );
2214  }
2215 
2216  template void _cvt_double_to( int *, double *, unsigned );
2217  template void _cvt_double_to( unsigned *, double *, unsigned );
2218  template void _cvt_double_to( long *, double *, unsigned );
2219  template void _cvt_double_to( unsigned long *, double *, unsigned );
2220  template void _cvt_double_to( short *, double *, unsigned );
2221  template void _cvt_double_to( unsigned short *, double *, unsigned );
2222  template void _cvt_double_to( float *, double *, unsigned );
2223  // Instantiate our templates. Octave uses
2224  // manual template instantiation.
2225 
2226 //
2227 // Convert an array of some other type into an array of doubles. Arguments:
2228 // 1) The array of objects of other type.
2229 // 2) The output array of doubles.
2230 // 3) The number of elements to convert.
2231 //
2232  template <class FLOAT>
2233  static inline void
2234  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2235  {
2236  while ( n_el-- > 0 )
2237  *d_arr++ = double(*arr++);
2238  }
2239 
2240  template void _cvt_to_double( int *, double *, unsigned );
2241  template void _cvt_to_double( unsigned *, double *, unsigned );
2242  template void _cvt_to_double( long *, double *, unsigned );
2243  template void _cvt_to_double( unsigned long *, double *, unsigned );
2244  template void _cvt_to_double( short *, double *, unsigned );
2245  template void _cvt_to_double( unsigned short *, double *, unsigned );
2246  template void _cvt_to_double( float *, double *, unsigned );
2247  // Instantiate our templates. Octave uses
2248  // manual template instantiation.
2249 
2250 
2251  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2252  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2253  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2254  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2255  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2257  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2258 
2259 
2260 #include <iostream>
2261 
2262  octave_function *fcnMapForm;
2263  std::string nameMapForm;
2264 
2265  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2266  {
2267  octave_idx_type i;
2268  octave_value_list functionArguments;
2269  octave_value_list retval;
2270 
2271  Matrix xin( n, 1 );
2272  Matrix yin( n, 1 );
2273  Matrix xout;
2274  Matrix yout;
2275 
2276  for ( i = 0; i < n; i++ )
2277  {
2278  xin( i, 0 ) = x[i];
2279  yin( i, 0 ) = y[i];
2280  }
2281 
2282  functionArguments( 0 ) = xin;
2283  functionArguments( 1 ) = yin;
2284 
2285  if ( fcnMapForm != NULL )
2286  retval = feval( fcnMapForm, functionArguments, 1 );
2287  else
2288  retval = feval( nameMapForm, functionArguments, 1 );
2289 
2290 
2291  if ( retval.length() >= 2 )
2292  {
2293  xout = retval( 0 ).matrix_value();
2294  yout = retval( 1 ).matrix_value();
2295 
2296  for ( i = 0; i < n; i++ )
2297  {
2298  x[i] = xout( i, 0 );
2299  y[i] = yout( i, 0 );
2300  }
2301  }
2302  }
2303 
2304 
2305  octave_function *fcnLabelFunc;
2306  std::string nameLabelFunc;
2307 
2308  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2309  {
2310  int i;
2311  octave_value_list functionArguments;
2312  octave_value_list retval;
2313 
2314  Matrix inAxis( 1, 1 );
2315  Matrix inValue( 1, 1 );
2316  inAxis( 0, 0 ) = axis;
2317  inValue( 0, 0 ) = value;
2318 
2319  functionArguments( 0 ) = inAxis;
2320  functionArguments( 1 ) = inValue;
2321 
2322  if ( fcnLabelFunc != NULL )
2323  retval = feval( fcnLabelFunc, functionArguments, 1 );
2324  else
2325  retval = feval( nameLabelFunc, functionArguments, 1 );
2326 
2327  strncpy( label, retval( 0 ).string_value().c_str(), length );
2328  }
2329 
2330 
2331  octave_function *fcnCoordTrans;
2332  std::string nameCoordTrans;
2333 
2334  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2335  {
2336  octave_idx_type i;
2337  octave_value_list functionArguments;
2338  octave_value_list retval;
2339 
2340  Matrix xin( 1, 1 );
2341  Matrix yin( 1, 1 );
2342  Matrix xout;
2343  Matrix yout;
2344 
2345  xin( 0, 0 ) = x;
2346  yin( 0, 0 ) = y;
2347 
2348  functionArguments( 0 ) = xin;
2349  functionArguments( 1 ) = yin;
2350 
2351  if ( fcnCoordTrans != NULL )
2352  retval = feval( fcnCoordTrans, functionArguments, 1 );
2353  else
2354  retval = feval( nameCoordTrans, functionArguments, 1 );
2355 
2356 
2357  if ( retval.length() >= 2 )
2358  {
2359  xout = retval( 0 ).matrix_value();
2360  yout = retval( 1 ).matrix_value();
2361 
2362  *xt = xout( 0, 0 );
2363  *yt = yout( 0, 0 );
2364  }
2365  }
2366 
2367 
2368  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2369  {
2370  PLINT i;
2371  printf( "nlegend =%d\n", nlegend );
2372  for ( i = 0; i < nlegend; i++ )
2373  {
2374  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2375  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2376  printf( "text[%d] =%s\n", i, text[i] );
2377  }
2378  }
2379 
2380 
2381 #include <limits.h>
2382 #if !defined(SWIG_NO_LLONG_MAX)
2383 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2384 # define LLONG_MAX __LONG_LONG_MAX__
2385 # define LLONG_MIN (-LLONG_MAX - 1LL)
2386 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2387 # endif
2388 #endif
2389 
2390 
2391  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2392  {
2393  if (!ov.is_scalar_type())
2394  return SWIG_TypeError;
2395  if (ov.is_complex_scalar())
2396  return SWIG_TypeError;
2397  if (ov.is_double_type()||ov.is_single_type()) {
2398  double v=ov.double_value();
2399  if (v!=floor(v))
2400  return SWIG_TypeError;
2401  }
2402  if (val)
2403  *val = ov.long_value();
2404  return SWIG_OK;
2405  }
2406 
2407 
2408 SWIGINTERN int
2409 SWIG_AsVal_int (octave_value obj, int *val)
2410 {
2411  long v;
2412  int res = SWIG_AsVal_long (obj, &v);
2413  if (SWIG_IsOK(res)) {
2414  if ((v < INT_MIN || v > INT_MAX)) {
2415  return SWIG_OverflowError;
2416  } else {
2417  if (val) *val = (int)(v);
2418  }
2419  }
2420  return res;
2421 }
2422 
2423 
2424  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 )
2425  {
2426  PLGraphicsIn gin;
2427  int status; status = plGetCursor( &gin );
2428  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2429  strncpy( string, gin.string, PL_MAXKEY - 1 );
2430  string[PL_MAXKEY - 1] = '\0';
2431 
2432  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2433  return status;
2434  }
2435 
2436 
2437 SWIGINTERN int
2438 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2439 {
2440  if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2441  ov = ov.cell_value()(0);
2442  if (!ov.is_string())
2443  return SWIG_TypeError;
2444 
2445  std::string str=ov.string_value();
2446  size_t len=str.size();
2447  char* cstr=(char*)str.c_str();
2448  if (alloc) {
2449  *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2450  *alloc = SWIG_NEWOBJ;
2451  } else if (cptr)
2452  *cptr = cstr;
2453  if (psize)
2454  *psize = len + 1;
2455  return SWIG_OK;
2456 }
2457 
2458 
2459 
2460 
2461 
2463  {
2464  return octave_value(value);
2465  }
2466 
2467 
2468 SWIGINTERNINLINE octave_value
2470 {
2471  return SWIG_From_long (value);
2472 }
2473 
2474 
2476  {
2477  return octave_value(value);
2478  }
2479 
2480 
2481 // Translates relative device coordinates to world coordinates.
2482  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2483  {
2484  PLGraphicsIn gin;
2485  int st;
2486  gin.dX = x_in; gin.dY = y_in;
2487  st = plTranslateCursor( &gin );
2488  *x = gin.wX; *y = gin.wY;
2489  return st;
2490  }
2491 
2492 
2493  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2494  {
2495  if (!ov.is_scalar_type())
2496  return SWIG_TypeError;
2497  if (ov.is_complex_scalar())
2498  return SWIG_TypeError;
2499  if (val)
2500  *val = ov.double_value();
2501  return SWIG_OK;
2502  }
2503 
2504 
2505 // Create 1d stripchart
2506 
2507  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2508  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2509  PLFLT xlpos, PLFLT ylpos,
2510  PLBOOL y_ascl, PLBOOL acc,
2511  PLINT colbox, PLINT collab,
2512  const PLINT *colline, const PLINT *styline,
2513  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2514  const char *labx, const char *laby, const char *labtop )
2515  {
2516  const char *legline[4];
2517  legline[0] = legline1; legline[1] = legline2;
2518  legline[2] = legline3; legline[3] = legline4;
2519  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2520  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2521  labx, laby, labtop );
2522  }
2523 
2524 
2525 // One more hack. As it is not possible (and would not be desirable) to pass
2526 // an Octave function to plcont(), I have defined three plcont():
2527 // plcont uses a defined here xform()
2528 // plcont0 uses pltr0()
2529 // plcont1 uses pltr1()
2530 // plcont2 uses pltr2()
2531 // plcont2p uses pltr2p()
2532 //
2533 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2534 // f2c, which is a #define that does the necessary conversion.
2535 //
2536 
2537  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2538  {
2539  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2540  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2541  }
2542 
2543 // convert from Fortran like arrays (one vector), to C like 2D arrays
2544 
2545 #define f2c( f, ff, nx, ny ) \
2546  PLFLT * *ff; \
2547  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2548  for ( int i = 0; i < nx; i++ ) { \
2549  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2550  for ( int j = 0; j < ny; j++ ) \
2551  *( ff[i] + j ) = *( f + nx * j + i );}
2552 
2553 // simpler plcont() for use with xform()
2554 
2555  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2556  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2557  {
2558  f2c( f, ff, nx, ny );
2559  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2560  }
2561 
2562 // plcont() for use with pltr0() NOT TESTED
2563 
2564  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2565  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2566  {
2567  f2c( f, ff, nx, ny );
2568  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2569  }
2570 
2571 // plcont() for use with pltr1()
2572 
2573  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2574  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2575  {
2576  PLcGrid grid1;
2577  grid1.nx = nx; grid1.ny = ny;
2578  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2579  f2c( f, ff, nx, ny );
2580  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2581  }
2582 
2583 // plcont() for use with pltr2()
2584  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2585  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2586  {
2587  PLcGrid2 grid2;
2588  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2589  grid2.nx = nx; grid2.ny = ny;
2590  grid2.xg = xgg; grid2.yg = ygg;
2591  f2c( f, ff, nx, ny );
2592  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2593  }
2594 
2595 // plcont() for use with pltr2p()
2596 
2597  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2598  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2599  {
2600  PLcGrid2 grid2;
2601  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2602  grid2.nx = nx; grid2.ny = ny;
2603  grid2.xg = xgg; grid2.yg = ygg;
2604  f2c( f, ff, nx, ny );
2605  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2606  }
2607 
2608 
2609  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2610  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2611  PLFLT *zg, int type, PLFLT data )
2612  {
2613  f2c( zg, zgg, nptsx, nptsy );
2614  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2615  for ( int i = 0; i < nptsx; i++ )
2616  for ( int j = 0; j < nptsy; j++ )
2617  *( zg + nptsx * j + i ) = zgg[i][j];
2618  }
2619 
2620 
2621 // Plots a mesh representation of the function z[x][y].
2622 
2623  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2624  {
2625  f2c( z, zz, nx, ny );
2626  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
2627  }
2628 
2629 // Plots a mesh representation of the function z[x][y] with contour
2630 
2631  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2632  {
2633  f2c( z, zz, nx, ny );
2634  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2635  }
2636 
2637 
2638 // Plots a 3-d representation of the function z[x][y].
2639  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2640  PLINT nx, PLINT ny, PLINT opt, PLINT side )
2641  {
2642  f2c( z, zz, nx, ny )
2643  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
2644  }
2645 
2646 // Plots a 3-d representation of the function z[x][y] with contour
2647  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2648  PLINT nx, PLINT ny, PLINT opt,
2649  const PLFLT *clevel, PLINT nlevel )
2650  {
2651  f2c( z, zz, nx, ny )
2652  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2653  }
2654 
2655 
2656  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2657  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2658  {
2659  f2c( z, zz, nx, ny )
2660  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2661  }
2662 
2663 
2664 // The same as in plcont. I have hardcoded the first function pointer
2665 // to plfill(). The second function pointer will use the same convention
2666 // as in plcont().
2667 //
2668 
2669 // the simpler plshade()
2670  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
2671  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2672  PLFLT shade_min, PLFLT shade_max,
2673  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2674  PLINT min_color, PLINT min_width,
2675  PLINT max_color, PLINT max_width,
2676  PLINT rectangular, PLFLT *tr )
2677  {
2678  f2c( a, aa, nx, ny );
2679  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2680  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2681  min_color, min_width, max_color, max_width,
2682  plfill, rectangular, xform, tr );
2683  }
2684 
2685 // plshade() for use with pltr1
2686  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2687  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2688  PLFLT shade_min, PLFLT shade_max,
2689  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2690  PLINT min_color, PLINT min_width,
2691  PLINT max_color, PLINT max_width,
2692  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2693  {
2694  PLcGrid grid1;
2695  grid1.nx = nx; grid1.ny = ny;
2696  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
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, pltr1, &grid1 );
2702  }
2703 
2704 // plshade() for use with pltr2
2705  void my_plshade2( 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  PLcGrid2 grid2;
2714  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2715  grid2.nx = nx; grid2.ny = ny;
2716  grid2.xg = xgg; grid2.yg = ygg;
2717  f2c( a, aa, nx, ny );
2718  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2719  shade_min, shade_max, sh_cmap, sh_color, sh_width,
2720  min_color, min_width, max_color, max_width,
2721  plfill, rectangular, pltr2, &grid2 );
2722  }
2723 
2724 
2725 
2726  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
2727  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2728  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2729  PLINT cont_color, PLINT cont_width,
2730  PLINT rectangular )
2731  {
2732  f2c( a, aa, nx, ny );
2733  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2734  clevel, nlevel, fill_width, cont_color, cont_width,
2735  plfill, rectangular, NULL, NULL );
2736  }
2737 
2738  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
2739  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2740  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2741  PLINT cont_color, PLINT cont_width,
2742  PLINT rectangular, PLFLT *tr )
2743  {
2744  f2c( a, aa, nx, ny );
2745  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2746  clevel, nlevel, fill_width, cont_color, cont_width,
2747  plfill, rectangular, xform, tr );
2748  }
2749 
2750  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
2751  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2752  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2753  PLINT cont_color, PLINT cont_width,
2754  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2755  {
2756  PLcGrid grid1;
2757  grid1.nx = nx; grid1.ny = ny;
2758  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2759 
2760  f2c( a, aa, nx, ny );
2761  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2762  clevel, nlevel, fill_width, cont_color, cont_width,
2763  plfill, rectangular, pltr1, &grid1 );
2764  }
2765 
2766  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
2767  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2768  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2769  PLINT cont_color, PLINT cont_width,
2770  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2771  {
2772  PLcGrid2 grid2;
2773  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2774  grid2.nx = nx; grid2.ny = ny;
2775  grid2.xg = xgg; grid2.yg = ygg;
2776  f2c( a, aa, nx, ny );
2777  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2778  clevel, nlevel, fill_width, cont_color, cont_width,
2779  plfill, rectangular, pltr2, &grid2 );
2780  }
2781 
2782 
2783 // Plot an array of vector arrows - uses the same function pointer
2784 // convention as plcont
2785 
2786  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2787  {
2788  f2c( u, uu, nx, ny );
2789  f2c( v, vv, nx, ny );
2790  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
2791  }
2792 
2793 // plvect() for use with pltr1
2794  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2795  {
2796  PLcGrid grid1;
2797  grid1.nx = nx; grid1.ny = ny;
2798  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2799  f2c( u, uu, nx, ny );
2800  f2c( v, vv, nx, ny );
2801  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
2802  }
2803 
2804 // plvect() for use with pltr2
2805  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2806  {
2807  PLcGrid2 grid2;
2808  f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2809  grid2.nx = nx; grid2.ny = ny;
2810  grid2.xg = xgg; grid2.yg = ygg;
2811  f2c( u, uu, nx, ny );
2812  f2c( v, vv, nx, ny );
2813  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
2814  }
2815 
2816 
2817 // Plot an image with distortion - uses the same function pointer
2818  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
2819  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2820  PLFLT zmin, PLFLT zmax,
2821  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2822  {
2823  f2c( a, aa, nx, ny );
2824  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2825  }
2826 
2827 // Plot an image with distortion - uses the same function pointer
2828 // convention as plcont
2829  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
2830  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2831  PLFLT zmin, PLFLT zmax,
2832  PLFLT valuemin, PLFLT valuemax )
2833  {
2834  f2c( a, aa, nx, ny );
2835  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2836  }
2837 
2838  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
2839  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2840  PLFLT zmin, PLFLT zmax,
2841  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2842  {
2843  f2c( a, aa, nx, ny );
2844  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
2845  }
2846 
2847 // plimagefr() for use with pltr1
2848  void my_plimagefr1( 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, const PLFLT *xg, const PLFLT *yg )
2852  {
2853  PLcGrid grid1;
2854  grid1.nx = nx + 1; grid1.ny = ny + 1;
2855  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2856  f2c( a, aa, nx, ny );
2857  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
2858  }
2859 
2860 // plimagefr() for use with pltr2
2861  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
2862  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2863  PLFLT zmin, PLFLT zmax,
2864  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2865  {
2866  PLcGrid2 grid2;
2867  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) ); f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2868  grid2.nx = nx + 1; grid2.ny = ny + 1;
2869  grid2.xg = xgg; grid2.yg = ygg;
2870  f2c( a, aa, nx, ny );
2871  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
2872  }
2873 
2874 
2875 
2876  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
2877  PLINT opt, PLINT position, PLFLT x, PLFLT y,
2878  PLFLT x_length, PLFLT y_length,
2879  PLINT bg_color, PLINT bb_color, PLINT bb_style,
2880  PLFLT low_cap_color, PLFLT high_cap_color,
2881  PLINT cont_color, PLFLT cont_width,
2882  PLINT n_labels, const PLINT *label_opts, const char **label,
2883  PLINT n_axes, const char ** axis_opts,
2884  const PLFLT *ticks, const PLINT *sub_ticks,
2885  const PLINT *n_values, const PLFLT *a )
2886  {
2887  PLINT nx, ny, i;
2888  nx = n_axes;
2889  ny = -1;
2890  for ( i = 0; i < nx; i++ )
2891  if ( n_values[i] > ny )
2892  ny = n_values[i];
2893  f2c( a, aa, nx, ny );
2894  c_plcolorbar( p_colorbar_width, p_colorbar_height,
2895  opt, position, x, y,
2896  x_length, y_length,
2897  bg_color, bb_color, bb_style,
2898  low_cap_color, high_cap_color,
2899  cont_color, cont_width,
2900  n_labels, label_opts, label,
2901  n_axes, axis_opts,
2902  ticks, sub_ticks,
2903  n_values, aa );
2904  }
2905 
2906 
2907 
2908  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
2909  {
2910  if (!ov.is_scalar_type())
2911  return SWIG_TypeError;
2912  if (ov.is_complex_scalar())
2913  return SWIG_TypeError;
2914  if (ov.is_double_type()||ov.is_single_type()) {
2915  double v=ov.double_value();
2916  if (v<0)
2917  return SWIG_OverflowError;
2918  if (v!=floor(v))
2919  return SWIG_TypeError;
2920  }
2921  if (ov.is_int8_type()||ov.is_int16_type()||
2922  ov.is_int32_type()) {
2923  long v=ov.long_value();
2924  if (v<0)
2925  return SWIG_OverflowError;
2926  }
2927  if (ov.is_int64_type()) {
2928  long long v=ov.int64_scalar_value().value();
2929  if (v<0)
2930  return SWIG_OverflowError;
2931  }
2932  if (val)
2933  *val = ov.ulong_value();
2934  return SWIG_OK;
2935  }
2936 
2937 
2938 SWIGINTERN int
2939 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
2940 {
2941  unsigned long v;
2942  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2943  if (SWIG_IsOK(res)) {
2944  if ((v > UINT_MAX)) {
2945  return SWIG_OverflowError;
2946  } else {
2947  if (val) *val = (unsigned int)(v);
2948  }
2949  }
2950  return res;
2951 }
2952 
2953 
2955  {
2956  return octave_value(value);
2957  }
2958 
2959 
2960 SWIGINTERNINLINE octave_value
2962 {
2963  return SWIG_From_unsigned_SS_long (value);
2964 }
2965 
2966 
2967 SWIGINTERN int
2968 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
2969 {
2970  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
2971  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
2972  if (SWIG_IsOK(res)) {
2973  if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
2974  if (csize <= size) {
2975  if (val) {
2976  if (csize) memcpy(val, cptr, csize*sizeof(char));
2977  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
2978  }
2979  if (alloc == SWIG_NEWOBJ) {
2980  delete[] cptr;
2981  res = SWIG_DelNewMask(res);
2982  }
2983  return res;
2984  }
2985  if (alloc == SWIG_NEWOBJ) delete[] cptr;
2986  }
2987  return SWIG_TypeError;
2988 }
2989 
2990 
2993 {
2994  static int init = 0;
2995  static swig_type_info* info = 0;
2996  if (!init) {
2997  info = SWIG_TypeQuery("_p_char");
2998  init = 1;
2999  }
3000  return info;
3001 }
3002 
3003 
3004 SWIGINTERNINLINE octave_value
3005 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3006 {
3007  return std::string(carray,carray+size);
3008 }
3009 
3010 
3011 SWIGINTERN int
3012 SWIG_AsVal_char (octave_value obj, char *val)
3013 {
3014  int res = SWIG_AsCharArray(obj, val, 1);
3015  if (!SWIG_IsOK(res)) {
3016  long v;
3017  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3018  if (SWIG_IsOK(res)) {
3019  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3020  if (val) *val = (char)(v);
3021  } else {
3022  res = SWIG_OverflowError;
3023  }
3024  }
3025  }
3026  return res;
3027 }
3028 
3029 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3030 Specify viewport in absolute coordinates \n\
3031 \n\
3032 DESCRIPTION:\n\
3033 \n\
3034  Alternate routine to plvpor for setting up the viewport. This routine\n\
3035  should be used only if the viewport is required to have a definite\n\
3036  size in millimeters. The routine plgspa is useful for finding out the\n\
3037  size of the current subpage. \n\
3038 \n\
3039  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3040 \n\
3041  This function is used in example 10. \n\
3042 \n\
3043 \n\
3044 \n\
3045 SYNOPSIS:\n\
3046 \n\
3047 plsvpa(xmin, xmax, ymin, ymax)\n\
3048 \n\
3049 ARGUMENTS:\n\
3050 \n\
3051  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3052  viewport from the left-hand edge of the subpage in millimeters. \n\
3053 \n\
3054  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3055  viewport from the left-hand edge of the subpage in millimeters. \n\
3056 \n\
3057  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3058  viewport from the bottom edge of the subpage in millimeters. \n\
3059 \n\
3060  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3061  from the bottom edge of the subpage in millimeters. \n\
3062 ";
3063 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3064 Write text relative to viewport boundaries in 3D plots. \n\
3065 \n\
3066 DESCRIPTION:\n\
3067 \n\
3068  Writes text at a specified position relative to the viewport\n\
3069  boundaries. Text may be written inside or outside the viewport, but\n\
3070  is clipped at the subpage boundaries. The reference point of a string\n\
3071  lies along a line passing through the string at half the height of a\n\
3072  capital letter. The position of the reference point along this line\n\
3073  is determined by just, and the position of the reference point\n\
3074  relative to the viewport is set by disp and pos. \n\
3075 \n\
3076  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3077 \n\
3078  This function is used in example 28. \n\
3079 \n\
3080 \n\
3081 \n\
3082 SYNOPSIS:\n\
3083 \n\
3084 plmtex3(side, disp, pos, just, text)\n\
3085 \n\
3086 ARGUMENTS:\n\
3087 \n\
3088  side (const char *, input) : Specifies the side of the viewport\n\
3089  along which the text is to be written. The string should contain\n\
3090  one or more of the following characters: [xyz][ps][v]. Only one\n\
3091  label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3092  both the X and Y axes. x: Label the X axis. \n\
3093  y: Label the Y axis. \n\
3094  z: Label the Z axis. \n\
3095  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3096  For X it is the axis that starts at y-min. For Y it is the\n\
3097  axis that starts at x-min. \n\
3098  s: Label the secondary axis. \n\
3099  v: Draw the text perpendicular to the axis. \n\
3100 \n\
3101 \n\
3102  disp (PLFLT, input) : Position of the reference point of string,\n\
3103  measured outwards from the specified viewport edge in units of the\n\
3104  current character height. Use negative disp to write within the\n\
3105  viewport. \n\
3106 \n\
3107  pos (PLFLT, input) : Position of the reference point of string\n\
3108  along the specified edge, expressed as a fraction of the length of\n\
3109  the edge. \n\
3110 \n\
3111  just (PLFLT, input) : Specifies the position of the string relative\n\
3112  to its reference point. If just=0., the reference point is at the\n\
3113  left and if just=1., it is at the right of the string. Other\n\
3114  values of just give intermediate justifications. \n\
3115 \n\
3116  text (const char *, input) : The string to be written out. \n\
3117 ";
3118 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3119 Set color map1 colors using 8-bit RGB values and double alpha values. \n\
3120 \n\
3121 DESCRIPTION:\n\
3122 \n\
3123  Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3124  documentation) and double alpha values. This also sets the number of\n\
3125  colors.\n\
3126 \n\
3127  This function is used in example 31. \n\
3128 \n\
3129 \n\
3130 \n\
3131 SYNOPSIS:\n\
3132 \n\
3133 plscmap1a(r, g, b, a, ncol1)\n\
3134 \n\
3135 ARGUMENTS:\n\
3136 \n\
3137  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3138  integers (0-255) representing the degree of red in the color. \n\
3139 \n\
3140  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3141  integers (0-255) representing the degree of green in the color. \n\
3142 \n\
3143  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3144  integers (0-255) representing the degree of blue in the color. \n\
3145 \n\
3146  a (PLFLT *, input) : Pointer to array with set of double values\n\
3147  (0.0-1.0) representing the alpha value of the color. \n\
3148 \n\
3149  ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n\
3150  arrays. \n\
3151 ";
3152 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3153 Select standard viewport \n\
3154 \n\
3155 DESCRIPTION:\n\
3156 \n\
3157  Sets up a standard viewport, leaving a left-hand margin of seven\n\
3158  character heights, and four character heights around the other three\n\
3159  sides. \n\
3160 \n\
3161  Redacted form: plvsta()\n\
3162 \n\
3163  This function is used in examples 1,12,14,17,25,29. \n\
3164 \n\
3165 \n\
3166 \n\
3167 SYNOPSIS:\n\
3168 \n\
3169 plvsta()\n\
3170 ";
3171 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3172 Switch to graphics screen \n\
3173 \n\
3174 DESCRIPTION:\n\
3175 \n\
3176  Sets an interactive device to graphics mode, used in conjunction with\n\
3177  pltext to allow graphics and text to be interspersed. On a device\n\
3178  which supports separate text and graphics windows, this command causes\n\
3179  control to be switched to the graphics window. If already in graphics\n\
3180  mode, this command is ignored. It is also ignored on devices which\n\
3181  only support a single window or use a different method for shifting\n\
3182  focus. See also pltext. \n\
3183 \n\
3184  Redacted form: plgra()\n\
3185 \n\
3186  This function is used in example 1. \n\
3187 \n\
3188 \n\
3189 \n\
3190 SYNOPSIS:\n\
3191 \n\
3192 plgra()\n\
3193 ";
3194 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3195 Set a given color from color map0 by 8 bit RGB value and double alpha value. \n\
3196 \n\
3197 DESCRIPTION:\n\
3198 \n\
3199  Set a given color by 8-bit RGB value and double alpha value for color \n\
3200  map0 (see the PLplot documentation). Overwrites the previous color\n\
3201  value for the given index and, thus, does not result in any\n\
3202  additional allocation of space for colors. \n\
3203 \n\
3204  This function is used in example 30. \n\
3205 \n\
3206 \n\
3207 \n\
3208 SYNOPSIS:\n\
3209 \n\
3210 plscol0a(icol0, r, g, b, a)\n\
3211 \n\
3212 ARGUMENTS:\n\
3213 \n\
3214  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3215  number of colors (which is set by default, by plscmap0n, or even\n\
3216  by plscmap0). \n\
3217 \n\
3218  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3219  degree of red in the color. \n\
3220 \n\
3221  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3222  degree of green in the color. \n\
3223 \n\
3224  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3225  degree of blue in the color. \n\
3226 \n\
3227  a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
3228  value of the color. \n\
3229 ";
3230 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3231 Set y axis parameters \n\
3232 \n\
3233 DESCRIPTION:\n\
3234 \n\
3235  Identical to plsxax, except that arguments are flags for y axis. See\n\
3236  the description of plsxax for more detail. \n\
3237 \n\
3238  Redacted form: plsyax(digmax, digits)\n\
3239 \n\
3240  This function is used in examples 1,14,31. \n\
3241 \n\
3242 \n\
3243 \n\
3244 SYNOPSIS:\n\
3245 \n\
3246 plsyax(digmax, digits)\n\
3247 \n\
3248 ARGUMENTS:\n\
3249 \n\
3250  digmax (PLINT, input) : Variable to set the maximum number of\n\
3251  digits for the y axis. If nonzero, the printed label will be\n\
3252  switched to a floating point representation when the number of\n\
3253  digits exceeds digmax. \n\
3254 \n\
3255  digits (PLINT, input) : Field digits value. Currently, changing\n\
3256  its value here has no effect since it is set only by plbox or\n\
3257  plbox3. However, the user may obtain its value after a call to\n\
3258  either of these functions by calling plgyax. \n\
3259 ";
3260 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3261 Returns 8-bit RGB values for given color from color map0 \n\
3262 \n\
3263 DESCRIPTION:\n\
3264 \n\
3265  Returns 8-bit RGB values (0-255) for given color from color map0 (see\n\
3266  the PLplot documentation).\tValues are negative if an invalid color id\n\
3267  is given. \n\
3268 \n\
3269  Redacted form: plgcol0(icol0, r, g, b)\n\
3270 \n\
3271  This function is used in example 2. \n\
3272 \n\
3273 \n\
3274 \n\
3275 SYNOPSIS:\n\
3276 \n\
3277 plgcol0(icol0, r, g, b)\n\
3278 \n\
3279 ARGUMENTS:\n\
3280 \n\
3281  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3282 \n\
3283  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3284 \n\
3285  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3286 \n\
3287  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3288 ";
3289 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3290 Set seed for internal random number generator. \n\
3291 \n\
3292 DESCRIPTION:\n\
3293 \n\
3294  Set the seed for the internal random number generator. See plrandd for\n\
3295  further details. \n\
3296 \n\
3297  Redacted form: plseed(seed)\n\
3298 \n\
3299  This function is used in example 21. \n\
3300 \n\
3301 \n\
3302 \n\
3303 SYNOPSIS:\n\
3304 \n\
3305 plseed(seed)\n\
3306 \n\
3307 ARGUMENTS:\n\
3308 \n\
3309  seed (unsigned int, input) : Seed for random number generator. \n\
3310 ";
3311 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3312 Get output file name \n\
3313 \n\
3314 DESCRIPTION:\n\
3315 \n\
3316  Gets the current output file name, if applicable. \n\
3317 \n\
3318  Redacted form: plgfnam(fnam)\n\
3319 \n\
3320  This function is used in example 31. \n\
3321 \n\
3322 \n\
3323 \n\
3324 SYNOPSIS:\n\
3325 \n\
3326 plgfnam(fnam)\n\
3327 \n\
3328 ARGUMENTS:\n\
3329 \n\
3330  fnam (char *, output) : Pointer to file name string (a preallocated\n\
3331  string of 80 characters or more). \n\
3332 ";
3333 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3334 Specify world coordinates of viewport boundaries \n\
3335 \n\
3336 DESCRIPTION:\n\
3337 \n\
3338  Sets up the world coordinates of the edges of the viewport. \n\
3339 \n\
3340  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3341 \n\
3342  This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3343 \n\
3344 \n\
3345 \n\
3346 SYNOPSIS:\n\
3347 \n\
3348 plwind(xmin, xmax, ymin, ymax)\n\
3349 \n\
3350 ARGUMENTS:\n\
3351 \n\
3352  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3353  of the viewport. \n\
3354 \n\
3355  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3356  of the viewport. \n\
3357 \n\
3358  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3359  the viewport. \n\
3360 \n\
3361  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3362  viewport. \n\
3363 ";
3364 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3365 Set color map1 colors using a piece-wise linear relationship \n\
3366 \n\
3367 DESCRIPTION:\n\
3368 \n\
3369  Set color map1 colors using a piece-wise linear relationship between\n\
3370  position in the color map (from 0 to 1) and position in HLS or RGB\n\
3371  color space (see the PLplot documentation). May be called at any\n\
3372  time. \n\
3373 \n\
3374  The idea here is to specify a number of control points that define the\n\
3375  mapping between palette 1 input positions (intensities) and HLS (or\n\
3376  RGB). Between these points, linear interpolation is used which gives\n\
3377  a smooth variation of color with input position. Any number of\n\
3378  control points may be specified, located at arbitrary positions,\n\
3379  although typically 2 - 4 are enough. Another way of stating this is\n\
3380  that we are traversing a given number of lines through HLS (or RGB)\n\
3381  space as we move through color map1 entries. The control points at\n\
3382  the minimum and maximum position (0 and 1) must always be specified. \n\
3383  By adding more control points you can get more variation. One good\n\
3384  technique for plotting functions that vary about some expected average\n\
3385  is to use an additional 2 control points in the center (position ~=\n\
3386  0.5) that are the same lightness as the background (typically white\n\
3387  for paper output, black for crt), and same hue as the boundary control\n\
3388  points. This allows the highs and lows to be very easily\n\
3389  distinguished. \n\
3390 \n\
3391  Each control point must specify the position in color map1 as well as\n\
3392  three coordinates in HLS or RGB space. The first point must\n\
3393  correspond to position = 0, and the last to position = 1. \n\
3394 \n\
3395  The default behaviour is for the hue to be linearly interpolated \n\
3396  between the control points. Since the hue lies in the range [0, 360]\n\
3397  this corresponds to interpolation around the \"front\" of the color\n\
3398  wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3399  alternative interpolation is used between control points i and i+1. If\n\
3400  hue[i+1]-hue[i] > 0 then interpolation is between\thue[i] and\n\
3401  hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n\
3402  consider this as interpolation around the \"back\" or \"reverse\" of the\n\
3403  color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3404  alt_hue_path[] = false for\tevery control point. \n\
3405 \n\
3406  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3407  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3408  240]truegreen-yellow-red-magenta-blue[240\n\
3409  120]trueblue-magenta-red-yellow-green\n\
3410 \n\
3411  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3412  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3413  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3414 \n\
3415  Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n\
3416  alt_hue_path)\n\
3417 \n\
3418  This function is used in examples 8,11,12,15,20,21. \n\
3419 \n\
3420 \n\
3421 \n\
3422 SYNOPSIS:\n\
3423 \n\
3424 plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n\
3425 \n\
3426 ARGUMENTS:\n\
3427 \n\
3428  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3429 \n\
3430  npts (PLINT, input) : number of control points \n\
3431 \n\
3432  pos (PLFLT *, input) : position for each control point (between 0.0\n\
3433  and 1.0, in ascending order) \n\
3434 \n\
3435  coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
3436  control point \n\
3437 \n\
3438  coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
3439  control point \n\
3440 \n\
3441  coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
3442  control point \n\
3443 \n\
3444  alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
3445  flag for each control point. (alt_hue_path[i] refers to the\n\
3446  interpolation interval between the i and i + 1 control points). \n\
3447 ";
3448 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3449 Set the pause (on end-of-page) status \n\
3450 \n\
3451 DESCRIPTION:\n\
3452 \n\
3453  Set the pause (on end-of-page) status. \n\
3454 \n\
3455  Redacted form: plspause(pause)\n\
3456 \n\
3457  This function is in examples 14,20. \n\
3458 \n\
3459 \n\
3460 \n\
3461 SYNOPSIS:\n\
3462 \n\
3463 plspause(pause)\n\
3464 \n\
3465 ARGUMENTS:\n\
3466 \n\
3467  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3468  end-of-page for those drivers which support this. Otherwise there\n\
3469  is no pause. \n\
3470 ";
3471 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
3472 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3473 \n\
3474 DESCRIPTION:\n\
3475 \n\
3476  Routine for creating a discrete plot legend with a plotted filled box,\n\
3477  line, and/or line of symbols for each annotated legend entry. The\n\
3478  arguments of pllegend provide control over the location and size of\n\
3479  the legend as well as the location and characteristics of the elements\n\
3480  (most of which are optional) within that legend. The resulting legend\n\
3481  is clipped at the boundaries of the current subpage. (N.B. the adopted\n\
3482  coordinate system used for some of the parameters is defined in the\n\
3483  documentation of the position parameter.) \n\
3484 \n\
3485  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3486  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3487  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3488  test_justification, text_colors, text, box_colors, box_patterns,\n\
3489  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3490  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3491 \n\
3492  This function is used in examples 4 and 26. \n\
3493 \n\
3494 \n\
3495 \n\
3496 SYNOPSIS:\n\
3497 \n\
3498 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\
3499 \n\
3500 ARGUMENTS:\n\
3501 \n\
3502  p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3503  contains (after the call) the legend width in adopted coordinates.\n\
3504  This quantity is calculated from plot_width, text_offset, ncolumn\n\
3505  (possibly modified inside the routine depending on nlegend and\n\
3506  nrow), and the length (calculated internally) of the longest text\n\
3507  string. \n\
3508 \n\
3509  p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3510  contains (after the call) the legend height in adopted\n\
3511  coordinates. This quantity is calculated from text_scale,\n\
3512  text_spacing, and nrow (possibly modified inside the routine\n\
3513  depending on nlegend and nrow). \n\
3514 \n\
3515  opt (PLINT, input) : opt contains bits controlling the overall\n\
3516  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3517  on the left of the legend and the plotted area on the right.\n\
3518  Otherwise, put the text area on the right of the legend and the\n\
3519  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3520  plot a (semi-transparent) background for the legend. If the\n\
3521  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3522  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3523  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3524  plot the resulting array of legend entries in row-major order.\n\
3525  Otherwise, plot the legend entries in column-major order. \n\
3526 \n\
3527  position (PLINT, input) : position contains bits controlling the\n\
3528  overall position of the legend and the definition of the adopted\n\
3529  coordinates used for positions. The combination of the\n\
3530  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP,\n\
3531  PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE\n\
3532  bits specifies one of the 16 possible standard positions (the 4\n\
3533  corners and 4 side centers for both the inside and outside cases)\n\
3534  of the legend relative to the adopted coordinate system. The\n\
3535  adopted coordinates are normalized viewport coordinates if the\n\
3536  PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates\n\
3537  if the PL_POSITION_SUBPAGE bit is set. Default position bits: If\n\
3538  none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or\n\
3539  PL_POSITION_BOTTOM are set, then use the combination of\n\
3540  PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of\n\
3541  PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use\n\
3542  PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3543  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3544 \n\
3545  x (PLFLT, input) : X offset of the legend position in adopted\n\
3546  coordinates from the specified standard position of the legend.\n\
3547  For positive x, the direction of motion away from the standard\n\
3548  position is inward/outward from the standard corner positions or\n\
3549  standard left or right positions if the\n\
3550  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3551  For the standard top or bottom positions, the direction of motion\n\
3552  is toward positive X. \n\
3553 \n\
3554  y (PLFLT, input) : Y offset of the legend position in adopted\n\
3555  coordinates from the specified standard position of the legend.\n\
3556  For positive y, the direction of motion away from the standard\n\
3557  position is inward/outward from the standard corner positions or\n\
3558  standard top or bottom positions if the\n\
3559  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3560  For the standard left or right positions, the direction of motion\n\
3561  is toward positive Y. \n\
3562 \n\
3563  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3564  of the plot area (where the colored boxes, lines, and/or lines of\n\
3565  symbols are drawn) of the legend. \n\
3566 \n\
3567  bg_color (PLINT, input) : The cmap0 index of the background color\n\
3568  for the legend (PL_LEGEND_BACKGROUND). \n\
3569 \n\
3570  bb_color (PLINT, input) : The cmap0 index of the color of the\n\
3571  bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3572 \n\
3573  bb_style (PLINT, input) : The cmap0 index of the background color\n\
3574  for the legend (PL_LEGEND_BACKGROUND). \n\
3575 \n\
3576  nrow (PLINT, input) : The cmap0 index of the background color for\n\
3577  the legend (PL_LEGEND_BACKGROUND). \n\
3578 \n\
3579  ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3580  for the legend (PL_LEGEND_BACKGROUND). \n\
3581 \n\
3582  nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3583  vertical height of the legend in adopted coordinates is calculated\n\
3584  internally from nlegend, text_scale (see below), and text_spacing\n\
3585  (see below). \n\
3586 \n\
3587  opt_array (const PLINT *, input) : Array of nlegend values of\n\
3588  options to control each individual plotted area corresponding to a\n\
3589  legend entry. If the \n\
3590  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3591  area. If the \n\
3592  PL_LEGEND_COLOR_BOX, \n\
3593  PL_LEGEND_LINE, and/or \n\
3594  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3595  entry is plotted with a colored box; a line; and/or a line of\n\
3596  symbols. \n\
3597 \n\
3598  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3599  area in units of character width. N.B. The total horizontal\n\
3600  width of the legend in adopted coordinates is calculated\n\
3601  internally from \n\
3602  plot_width (see above), \n\
3603  text_offset, and length (calculated internally) of the longest text\n\
3604  string. \n\
3605 \n\
3606  text_scale (PLFLT, input) : Character height scale for text\n\
3607  annotations. N.B. The total vertical height of the legend in\n\
3608  adopted coordinates is calculated internally from \n\
3609  nlegend (see above), \n\
3610  text_scale, and \n\
3611  text_spacing (see below). \n\
3612 \n\
3613  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3614  character height from one legend entry to the next. N.B. The\n\
3615  total vertical height of the legend in adopted coordinates is\n\
3616  calculated internally from \n\
3617  nlegend (see above), \n\
3618  text_scale (see above), and \n\
3619  text_spacing. \n\
3620 \n\
3621  text_justification (PLFLT, input) : Justification parameter used\n\
3622  for text justification. The most common values of\n\
3623  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3624  is left justified, centred, or right justified within the text\n\
3625  area, but other values are allowed as well. \n\
3626 \n\
3627  text_colors (const PLINT *, input) : Array of nlegend text colors\n\
3628  (cmap0 indices). \n\
3629 \n\
3630  text (const char **, input) : Array of nlegend text string\n\
3631  annotations. \n\
3632 \n\
3633  box_colors (const PLINT *, input) : Array of nlegend colors (cmap0\n\
3634  indices) for the discrete colored boxes (\n\
3635  PL_LEGEND_COLOR_BOX). \n\
3636 \n\
3637  box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3638  (plpsty indices) for the discrete colored boxes (\n\
3639  PL_LEGEND_COLOR_BOX). \n\
3640 \n\
3641  box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3642  of fraction of character height) for the height of the discrete\n\
3643  colored boxes (\n\
3644  PL_LEGEND_COLOR_BOX). \n\
3645 \n\
3646  box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3647  widths for the patterns specified by box_patterns (\n\
3648  PL_LEGEND_COLOR_BOX). \n\
3649 \n\
3650  line_colors (const PLINT *, input) : Array of nlegend line colors\n\
3651  (cmap0 indices) (\n\
3652  PL_LEGEND_LINE). \n\
3653 \n\
3654  line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3655  (plsty indices) (\n\
3656  PL_LEGEND_LINE). \n\
3657 \n\
3658  line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3659  PL_LEGEND_LINE). \n\
3660 \n\
3661  symbol_colors (const PLINT *, input) : Array of nlegend symbol\n\
3662  colors (cmap0 indices) (\n\
3663  PL_LEGEND_SYMBOL). \n\
3664 \n\
3665  symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3666  values for the symbol height (\n\
3667  PL_LEGEND_SYMBOL). \n\
3668 \n\
3669  symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3670  symbols to be drawn across the width of the plotted area (\n\
3671  PL_LEGEND_SYMBOL). \n\
3672 \n\
3673  symbols (const char **, input) : Array of nlegend symbols (plpoin\n\
3674  indices) (\n\
3675  PL_LEGEND_SYMBOL). \n\
3676 ";
3677 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
3678 Set number of colors in color map1 \n\
3679 \n\
3680 DESCRIPTION:\n\
3681 \n\
3682  Set number of colors in color map1, (re-)allocate color map1, and set\n\
3683  default values if this is the first allocation (see the PLplot\n\
3684  documentation). \n\
3685 \n\
3686  Redacted form: plscmap1n(ncol1)\n\
3687 \n\
3688  This function is used in examples 8,11,20,21. \n\
3689 \n\
3690 \n\
3691 \n\
3692 SYNOPSIS:\n\
3693 \n\
3694 plscmap1n(ncol1)\n\
3695 \n\
3696 ARGUMENTS:\n\
3697 \n\
3698  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3699  the map1 palette. If this number is zero or less, then the value\n\
3700  from the previous call to plscmap1n is used and if there is no\n\
3701  previous call, then a default value is used. \n\
3702 ";
3703 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
3704 Returns 8-bit RGB values and double alpha value for given color from color map0. \n\
3705 \n\
3706 DESCRIPTION:\n\
3707 \n\
3708  Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n\
3709  for given color from color map0 (see the PLplot documentation). \n\
3710  Values are negative if an invalid color id is given. \n\
3711 \n\
3712  This function is used in example 30. \n\
3713 \n\
3714 \n\
3715 \n\
3716 SYNOPSIS:\n\
3717 \n\
3718 plgcol0a(icol0, r, g, b, a)\n\
3719 \n\
3720 ARGUMENTS:\n\
3721 \n\
3722  icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3723 \n\
3724  r (PLINT *, output) : Pointer to 8-bit red value. \n\
3725 \n\
3726  g (PLINT *, output) : Pointer to 8-bit green value. \n\
3727 \n\
3728  b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3729 \n\
3730  a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
3731 ";
3732 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
3733 Replays contents of plot buffer to current device/file \n\
3734 \n\
3735 DESCRIPTION:\n\
3736 \n\
3737  Replays contents of plot buffer to current device/file. \n\
3738 \n\
3739  Redacted form: plreplot()\n\
3740 \n\
3741  This function is used in example 1,20. \n\
3742 \n\
3743 \n\
3744 \n\
3745 SYNOPSIS:\n\
3746 \n\
3747 plreplot()\n\
3748 ";
3749 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
3750 Simple routine to write labels \n\
3751 \n\
3752 DESCRIPTION:\n\
3753 \n\
3754  Routine for writing simple labels. Use plmtex for more complex labels. \n\
3755 \n\
3756  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3757 \n\
3758  This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3759 \n\
3760 \n\
3761 \n\
3762 SYNOPSIS:\n\
3763 \n\
3764 pllab(xlabel, ylabel, tlabel)\n\
3765 \n\
3766 ARGUMENTS:\n\
3767 \n\
3768  xlabel (const char *, input) : Label for horizontal axis. \n\
3769 \n\
3770  ylabel (const char *, input) : Label for vertical axis. \n\
3771 \n\
3772  tlabel (const char *, input) : Title of graph. \n\
3773 ";
3774 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
3775 Set parameters that define current device-space window \n\
3776 \n\
3777 DESCRIPTION:\n\
3778 \n\
3779  Set relative margin width, aspect ratio, and relative justification\n\
3780  that define current device-space window. If you want to just use the\n\
3781  previous value for any of these, just pass in the magic value\n\
3782  PL_NOTSET. It is unlikely that one should ever need to change the\n\
3783  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3784  called the default values of mar, jx, and jy are all 0. aspect is set\n\
3785  to a device-specific value. \n\
3786 \n\
3787  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3788 \n\
3789  This function is used in example 31. \n\
3790 \n\
3791 \n\
3792 \n\
3793 SYNOPSIS:\n\
3794 \n\
3795 plsdidev(mar, aspect, jx, jy)\n\
3796 \n\
3797 ARGUMENTS:\n\
3798 \n\
3799  mar (PLFLT, input) : Relative margin width. \n\
3800 \n\
3801  aspect (PLFLT, input) : Aspect ratio. \n\
3802 \n\
3803  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3804  the range -0.5 to 0.5. \n\
3805 \n\
3806  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3807  the range -0.5 to 0.5. \n\
3808 ";
3809 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
3810 Begin a new page\n\
3811 \n\
3812 DESCRIPTION:\n\
3813 \n\
3814  Begins a new page.\tFor a file driver, the output file is opened if\n\
3815  necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3816  page break is desired at a particular point when plotting to subpages.\n\
3817  Another use for pleop and plbop is when plotting pages to different\n\
3818  files, since you can manually set the file name by calling plsfnam\n\
3819  after the call to pleop. (In fact some drivers may only support a\n\
3820  single page per file, making this a necessity.) One way to handle\n\
3821  this case automatically is to page advance via pladv, but enable\n\
3822  familying (see plsfam) with a small limit on the file size so that a\n\
3823  new family member file will be created on each page break. \n\
3824 \n\
3825  Redacted form: plbop()\n\
3826 \n\
3827  This function is used in examples 2,20. \n\
3828 \n\
3829 \n\
3830 \n\
3831 SYNOPSIS:\n\
3832 \n\
3833 plbop()\n\
3834 ";
3835 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
3836 Set color map0 colors by 8-bit RGB values \n\
3837 \n\
3838 DESCRIPTION:\n\
3839 \n\
3840  Set color map0 colors using 8-bit RGB values (see the PLplot\n\
3841  documentation). This sets the entire color map -- only as many colors\n\
3842  as specified will be allocated. \n\
3843 \n\
3844  Redacted form: plscmap0(r, g, b, ncol0)\n\
3845 \n\
3846  This function is used in examples 2,24. \n\
3847 \n\
3848 \n\
3849 \n\
3850 SYNOPSIS:\n\
3851 \n\
3852 plscmap0(r, g, b, ncol0)\n\
3853 \n\
3854 ARGUMENTS:\n\
3855 \n\
3856  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3857  integers (0-255) representing the degree of red in the color. \n\
3858 \n\
3859  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3860  integers (0-255) representing the degree of green in the color. \n\
3861 \n\
3862  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3863  integers (0-255) representing the degree of blue in the color. \n\
3864 \n\
3865  ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3866 ";
3867 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
3868 Set the number of subpages in x and y \n\
3869 \n\
3870 DESCRIPTION:\n\
3871 \n\
3872  Set the number of subpages in x and y. \n\
3873 \n\
3874  Redacted form: plssub(nx, ny)\n\
3875 \n\
3876  This function is examples 1,2,14,21,25,27. \n\
3877 \n\
3878 \n\
3879 \n\
3880 SYNOPSIS:\n\
3881 \n\
3882 plssub(nx, ny)\n\
3883 \n\
3884 ARGUMENTS:\n\
3885 \n\
3886  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
3887  of window columns). \n\
3888 \n\
3889  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
3890  of window rows). \n\
3891 ";
3892 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
3893 Set a global coordinate transform function \n\
3894 \n\
3895 DESCRIPTION:\n\
3896 \n\
3897  This function can be used to define a coordinate transformation which\n\
3898  affects all elements drawn within the current plot window.\tThe\n\
3899  transformation function is similar to that provided for the plmap and\n\
3900  plmeridians functions. The data parameter may be used to pass extra\n\
3901  data to transform_fun. \n\
3902 \n\
3903  Redacted form: General: plstransform(transform_fun, data)\n\
3904 \n\
3905 \n\
3906  This function is used in example 19. \n\
3907 \n\
3908 \n\
3909 \n\
3910 SYNOPSIS:\n\
3911 \n\
3912 plstransform(transform_fun, data)\n\
3913 \n\
3914 ARGUMENTS:\n\
3915 \n\
3916  transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n\
3917  input) : Pointer to a function that defines a transformation\n\
3918  from the input (x, y) coordinate to a new plot world coordiante. \n\
3919 \n\
3920  data (PLPointer, input) : Optional extra data for \n\
3921  transform_fun. \n\
3922 ";
3923 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
3924 Set color map1 colors using 8-bit RGB values \n\
3925 \n\
3926 DESCRIPTION:\n\
3927 \n\
3928  Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3929  documentation). This also sets the number of colors. \n\
3930 \n\
3931  Redacted form: plscmap1(r, g, b, ncol1)\n\
3932 \n\
3933  This function is used in example 31. \n\
3934 \n\
3935 \n\
3936 \n\
3937 SYNOPSIS:\n\
3938 \n\
3939 plscmap1(r, g, b, ncol1)\n\
3940 \n\
3941 ARGUMENTS:\n\
3942 \n\
3943  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3944  integers (0-255) representing the degree of red in the color. \n\
3945 \n\
3946  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3947  integers (0-255) representing the degree of green in the color. \n\
3948 \n\
3949  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3950  integers (0-255) representing the degree of blue in the color. \n\
3951 \n\
3952  ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3953 ";
3954 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
3955 Set length of minor ticks \n\
3956 \n\
3957 DESCRIPTION:\n\
3958 \n\
3959  This sets up the length of the minor ticks and the length of the\n\
3960  terminals on error bars. The actual length is the product of the\n\
3961  default length and a scaling factor as for character height. \n\
3962 \n\
3963  Redacted form: plsmin(def, scale)\n\
3964 \n\
3965  This function is used in example 29. \n\
3966 \n\
3967 \n\
3968 \n\
3969 SYNOPSIS:\n\
3970 \n\
3971 plsmin(def, scale)\n\
3972 \n\
3973 ARGUMENTS:\n\
3974 \n\
3975  def (PLFLT, input) : The default length of a minor tick in\n\
3976  millimeters, should be set to zero if the default length is to\n\
3977  remain unchanged. \n\
3978 \n\
3979  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
3980  actual tick length. \n\
3981 ";
3982 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
3983 Set character size \n\
3984 \n\
3985 DESCRIPTION:\n\
3986 \n\
3987  This sets up the size of all subsequent characters drawn. The actual\n\
3988  height of a character is the product of the default character size and\n\
3989  a scaling factor. \n\
3990 \n\
3991  Redacted form: plschr(def, scale)\n\
3992 \n\
3993  This function is used in example 2,13,23,24. \n\
3994 \n\
3995 \n\
3996 \n\
3997 SYNOPSIS:\n\
3998 \n\
3999 plschr(def, scale)\n\
4000 \n\
4001 ARGUMENTS:\n\
4002 \n\
4003  def (PLFLT, input) : The default height of a character in\n\
4004  millimeters, should be set to zero if the default height is to\n\
4005  remain unchanged. \n\
4006 \n\
4007  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4008  actual character height. \n\
4009 ";
4010 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4011 Initialize PLplot \n\
4012 \n\
4013 DESCRIPTION:\n\
4014 \n\
4015  Initializing the plotting package.\tThe program prompts for the device\n\
4016  keyword or number of the desired output device. Hitting a RETURN in\n\
4017  response to the prompt is the same as selecting the first device. \n\
4018  plinit will issue no prompt if either the device was specified\n\
4019  previously (via command line flag, the plsetopt function, or the\n\
4020  plsdev function), or if only one device is enabled when PLplot is\n\
4021  installed.\tIf subpages have been specified, the output device is\n\
4022  divided into nx by ny subpages, each of which may be used\n\
4023  independently. If plinit is called again during a program, the\n\
4024  previously opened file will be closed. The subroutine pladv is used\n\
4025  to advance from one subpage to the next. \n\
4026 \n\
4027  Redacted form: plinit()\n\
4028 \n\
4029  This function is used in all of the examples. \n\
4030 \n\
4031 \n\
4032 \n\
4033 SYNOPSIS:\n\
4034 \n\
4035 plinit()\n\
4036 ";
4037 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4038 Draw a box with axes, etc\n\
4039 \n\
4040 DESCRIPTION:\n\
4041 \n\
4042  Draws a box around the currently defined viewport, and labels it with\n\
4043  world coordinate values appropriate to the window.\tThus plbox should\n\
4044  only be called after defining both viewport and window. The character\n\
4045  strings xopt and yopt specify how the box should be drawn as described\n\
4046  below. If ticks and/or subticks are to be drawn for a particular\n\
4047  axis, the tick intervals and number of subintervals may be specified\n\
4048  explicitly, or they may be defaulted by setting the appropriate\n\
4049  arguments to zero. \n\
4050 \n\
4051  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4052 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4053 \n\
4054 \n\
4055  This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4056 \n\
4057 \n\
4058 \n\
4059 SYNOPSIS:\n\
4060 \n\
4061 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4062 \n\
4063 ARGUMENTS:\n\
4064 \n\
4065  xopt (const char *, input) : Pointer to character string specifying\n\
4066  options for horizontal axis. The string can include any\n\
4067  combination of the following letters (upper or lower case) in any\n\
4068  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4069  is vertical line (x=0). \n\
4070  b: Draws bottom (X) or left (Y) edge of frame. \n\
4071  c: Draws top (X) or right (Y) edge of frame. \n\
4072  d: Plot labels as date / time. Values are assumed to be\n\
4073  seconds since the epoch (as used by gmtime). \n\
4074  f: Always use fixed point numeric labels. \n\
4075  g: Draws a grid at the major tick interval. \n\
4076  h: Draws a grid at the minor tick interval. \n\
4077  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4078  inwards. \n\
4079  l: Labels axis logarithmically. This only affects the labels,\n\
4080  not the data, and so it is necessary to compute the logarithms\n\
4081  of data points before passing them to any of the drawing\n\
4082  routines. \n\
4083  m: Writes numeric labels at major tick intervals in the\n\
4084  unconventional location (above box for X, right of box for Y). \n\
4085  n: Writes numeric labels at major tick intervals in the\n\
4086  conventional location (below box for X, left of box for Y). \n\
4087  o: Use custom labeling function to generate axis label text. \n\
4088  The custom labeling function can be defined with the\n\
4089  plslabelfuncplslabelfunc; command. \n\
4090  s: Enables subticks between major ticks, only valid if t is\n\
4091  also specified. \n\
4092  t: Draws major ticks. \n\
4093  u: Exactly like \"b\" except don\'t draw edge line. \n\
4094  w: Exactly like \"c\" except don\'t draw edge line. \n\
4095 \n\
4096 \n\
4097  xtick (PLFLT, input) : World coordinate interval between major\n\
4098  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4099  generates a suitable tick interval. \n\
4100 \n\
4101  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4102  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4103  generates a suitable minor tick interval. \n\
4104 \n\
4105  yopt (const char *, input) : Pointer to character string specifying\n\
4106  options for vertical axis. The string can include any combination\n\
4107  of the letters defined above for xopt, and in addition may\n\
4108  contain: v: Write numeric labels for vertical axis parallel to the\n\
4109  base of the graph, rather than parallel to the axis. \n\
4110 \n\
4111 \n\
4112  ytick (PLFLT, input) : World coordinate interval between major\n\
4113  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4114  generates a suitable tick interval. \n\
4115 \n\
4116  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4117  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4118  generates a suitable minor tick interval. \n\
4119 ";
4120 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4121 Get parameters that define current device-space window \n\
4122 \n\
4123 DESCRIPTION:\n\
4124 \n\
4125  Get relative margin width, aspect ratio, and relative justification\n\
4126  that define current device-space window. If plsdidev has not been\n\
4127  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4128  p_jy will all be 0. \n\
4129 \n\
4130  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4131 \n\
4132  This function is used in example 31. \n\
4133 \n\
4134 \n\
4135 \n\
4136 SYNOPSIS:\n\
4137 \n\
4138 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4139 \n\
4140 ARGUMENTS:\n\
4141 \n\
4142  p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4143 \n\
4144  p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4145 \n\
4146  p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4147 \n\
4148  p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4149 ";
4150 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4151 Plot a glyph at the specified points \n\
4152 \n\
4153 DESCRIPTION:\n\
4154 \n\
4155  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4156  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4157  is specified with a PLplot user string. Note that the user string is\n\
4158  not actually limited to one glyph so it is possible (but not normally\n\
4159  useful) to plot more than one glyph at the specified points with this\n\
4160  function. As with plmtex and plptex, the user string can contain FCI\n\
4161  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4162  else PLplot escapes for Hershey or unicode text to determine the\n\
4163  glyph. \n\
4164 \n\
4165  Redacted form: plstring(x, y, string)\n\
4166 \n\
4167  This function is used in examples 4, 21 and 26. \n\
4168 \n\
4169 \n\
4170 \n\
4171 SYNOPSIS:\n\
4172 \n\
4173 plstring(n, x, y, string)\n\
4174 \n\
4175 ARGUMENTS:\n\
4176 \n\
4177  n (PLINT, input) : Number of points in the x and y arrays. \n\
4178 \n\
4179  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
4180  points. \n\
4181 \n\
4182  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
4183  points. \n\
4184 \n\
4185  string (const char *, input) : PLplot user string corresponding to\n\
4186  the glyph to be plotted at each of the n points. \n\
4187 ";
4188 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4189 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n\
4190 \n\
4191 DESCRIPTION:\n\
4192 \n\
4193  Sets up plotter environment for simple graphs by calling pladv and\n\
4194  setting up viewport and window to sensible default values.\tplenv0\n\
4195  leaves enough room around most graphs for axis labels and a title.\n\
4196  When these defaults are not suitable, use the individual routines\n\
4197  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4198  defining the window, and plbox for drawing the box. \n\
4199 \n\
4200  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4201 \n\
4202  This function is used in example 21. \n\
4203 \n\
4204 \n\
4205 \n\
4206 SYNOPSIS:\n\
4207 \n\
4208 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4209 \n\
4210 ARGUMENTS:\n\
4211 \n\
4212  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4213  world coordinates). \n\
4214 \n\
4215  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4216  world coordinates). \n\
4217 \n\
4218  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4219  coordinates). \n\
4220 \n\
4221  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4222  coordinates). \n\
4223 \n\
4224  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4225  scales will not be set, the user must set up the scale before\n\
4226  calling plenv0 using plsvpa, plvasp or other. \n\
4227  0: the x and y axes are scaled independently to use as much of\n\
4228  the screen as possible. \n\
4229  1: the scales of the x and y axes are made equal. \n\
4230  2: the axis of the x and y axes are made equal, and the plot\n\
4231  box will be square. \n\
4232 \n\
4233 \n\
4234  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4235  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4236  -1: draw box only. \n\
4237  0: draw box, ticks, and numeric tick labels. \n\
4238  1: also draw coordinate axes at x=0 and y=0. \n\
4239  2: also draw a grid at major tick positions in both\n\
4240  coordinates. \n\
4241  3: also draw a grid at minor tick positions in both\n\
4242  coordinates. \n\
4243  10: same as 0 except logarithmic x tick marks. (The x data\n\
4244  have to be converted to logarithms separately.) \n\
4245  11: same as 1 except logarithmic x tick marks. (The x data\n\
4246  have to be converted to logarithms separately.) \n\
4247  12: same as 2 except logarithmic x tick marks. (The x data\n\
4248  have to be converted to logarithms separately.) \n\
4249  13: same as 3 except logarithmic x tick marks. (The x data\n\
4250  have to be converted to logarithms separately.) \n\
4251  20: same as 0 except logarithmic y tick marks. (The y data\n\
4252  have to be converted to logarithms separately.) \n\
4253  21: same as 1 except logarithmic y tick marks. (The y data\n\
4254  have to be converted to logarithms separately.) \n\
4255  22: same as 2 except logarithmic y tick marks. (The y data\n\
4256  have to be converted to logarithms separately.) \n\
4257  23: same as 3 except logarithmic y tick marks. (The y data\n\
4258  have to be converted to logarithms separately.) \n\
4259  30: same as 0 except logarithmic x and y tick marks. (The x\n\
4260  and y data have to be converted to logarithms separately.) \n\
4261  31: same as 1 except logarithmic x and y tick marks. (The x\n\
4262  and y data have to be converted to logarithms separately.) \n\
4263  32: same as 2 except logarithmic x and y tick marks. (The x\n\
4264  and y data have to be converted to logarithms separately.) \n\
4265  33: same as 3 except logarithmic x and y tick marks. (The x\n\
4266  and y data have to be converted to logarithms separately.) \n\
4267  40: same as 0 except date / time x labels. \n\
4268  41: same as 1 except date / time x labels. \n\
4269  42: same as 2 except date / time x labels. \n\
4270  43: same as 3 except date / time x labels. \n\
4271  50: same as 0 except date / time y labels. \n\
4272  51: same as 1 except date / time y labels. \n\
4273  52: same as 2 except date / time y labels. \n\
4274  53: same as 3 except date / time y labels. \n\
4275  60: same as 0 except date / time x and y labels. \n\
4276  61: same as 1 except date / time x and y labels. \n\
4277  62: same as 2 except date / time x and y labels. \n\
4278  63: same as 3 except date / time x and y labels. \n\
4279  70: same as 0 except custom x and y labels. \n\
4280  71: same as 1 except custom x and y labels. \n\
4281  72: same as 2 except custom x and y labels. \n\
4282  73: same as 3 except custom x and y labels. \n\
4283 ";
4284 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
4285 Set up window for 3-d plotting \n\
4286 \n\
4287 DESCRIPTION:\n\
4288 \n\
4289  Sets up a window for a three-dimensional surface plot within the\n\
4290  currently defined two-dimensional window. The enclosing box for the\n\
4291  surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4292  user-coordinate space is mapped into a box of world coordinate size\n\
4293  basex by basey by height so that xmin maps to -\n\
4294  basex/2, xmax maps to basex/2, ymin maps to -\n\
4295  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4296  The resulting world-coordinate box is then viewed by an observer at\n\
4297  altitude alt and azimuth az. This routine must be called before\n\
4298  plbox3 or plot3d. For a more complete description of\n\
4299  three-dimensional plotting see the PLplot documentation. \n\
4300 \n\
4301  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4302  zmin, zmax, alt, az)\n\
4303 \n\
4304  This function is examples 8,11,18,21. \n\
4305 \n\
4306 \n\
4307 \n\
4308 SYNOPSIS:\n\
4309 \n\
4310 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4311 \n\
4312 ARGUMENTS:\n\
4313 \n\
4314  basex (PLFLT, input) : The x coordinate size of the\n\
4315  world-coordinate box. \n\
4316 \n\
4317  basey (PLFLT, input) : The y coordinate size of the\n\
4318  world-coordinate box. \n\
4319 \n\
4320  height (PLFLT, input) : The z coordinate size of the\n\
4321  world-coordinate box. \n\
4322 \n\
4323  xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4324 \n\
4325  xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4326 \n\
4327  ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4328 \n\
4329  ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4330 \n\
4331  zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4332 \n\
4333  zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4334 \n\
4335  alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4336  plane. \n\
4337 \n\
4338  az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n\
4339  observer is looking face onto the ZX plane, and as az is\n\
4340  increased, the observer moves clockwise around the box when viewed\n\
4341  from above the XY plane. \n\
4342 ";
4343 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4344 Draw filled polygon \n\
4345 \n\
4346 DESCRIPTION:\n\
4347 \n\
4348  Fills the polygon defined by the n points (\n\
4349  x[i], \n\
4350  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4351  style is a solid fill. The routine will automatically close the\n\
4352  polygon between the last and first vertices. If multiple closed\n\
4353  polygons are passed in x and y then plfill will fill in between them. \n\
4354 \n\
4355  Redacted form: plfill(x,y)\n\
4356 \n\
4357  This function is used in examples 12,13,15,16,21,24,25. \n\
4358 \n\
4359 \n\
4360 \n\
4361 SYNOPSIS:\n\
4362 \n\
4363 plfill(n, x, y)\n\
4364 \n\
4365 ARGUMENTS:\n\
4366 \n\
4367  n (PLINT, input) : Number of vertices in polygon. \n\
4368 \n\
4369  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4370  vertices. \n\
4371 \n\
4372  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4373  vertices. \n\
4374 ";
4375 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
4376 Write text relative to viewport boundaries \n\
4377 \n\
4378 DESCRIPTION:\n\
4379 \n\
4380  Writes text at a specified position relative to the viewport\n\
4381  boundaries. Text may be written inside or outside the viewport, but\n\
4382  is clipped at the subpage boundaries. The reference point of a string\n\
4383  lies along a line passing through the string at half the height of a\n\
4384  capital letter. The position of the reference point along this line\n\
4385  is determined by just, and the position of the reference point\n\
4386  relative to the viewport is set by disp and pos. \n\
4387 \n\
4388  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4389 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4390 \n\
4391 \n\
4392  This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4393 \n\
4394 \n\
4395 \n\
4396 SYNOPSIS:\n\
4397 \n\
4398 plmtex(side, disp, pos, just, text)\n\
4399 \n\
4400 ARGUMENTS:\n\
4401 \n\
4402  side (const char *, input) : Specifies the side of the viewport\n\
4403  along which the text is to be written. The string must be one of:\n\
4404  b: Bottom of viewport, text written parallel to edge. \n\
4405  bv: Bottom of viewport, text written at right angles to edge. \n\
4406  l: Left of viewport, text written parallel to edge. \n\
4407  lv: Left of viewport, text written at right angles to edge. \n\
4408  r: Right of viewport, text written parallel to edge. \n\
4409  rv: Right of viewport, text written at right angles to edge. \n\
4410  t: Top of viewport, text written parallel to edge. \n\
4411  tv: Top of viewport, text written at right angles to edge. \n\
4412 \n\
4413 \n\
4414  disp (PLFLT, input) : Position of the reference point of string,\n\
4415  measured outwards from the specified viewport edge in units of the\n\
4416  current character height. Use negative disp to write within the\n\
4417  viewport. \n\
4418 \n\
4419  pos (PLFLT, input) : Position of the reference point of string\n\
4420  along the specified edge, expressed as a fraction of the length of\n\
4421  the edge. \n\
4422 \n\
4423  just (PLFLT, input) : Specifies the position of the string relative\n\
4424  to its reference point. If just=0., the reference point is at the\n\
4425  left and if just=1., it is at the right of the string. Other\n\
4426  values of just give intermediate justifications. \n\
4427 \n\
4428  text (const char *, input) : The string to be written out. \n\
4429 ";
4430 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4431 Set arrow style for vector plots \n\
4432 \n\
4433 DESCRIPTION:\n\
4434 \n\
4435  Set the style for the arrow used by plvect to plot vectors. \n\
4436 \n\
4437  Redacted form: plsvect(arrowx, arrowy, fill)\n\
4438 \n\
4439  This function is used in example 22. \n\
4440 \n\
4441 \n\
4442 \n\
4443 SYNOPSIS:\n\
4444 \n\
4445 plsvect(arrowx, arrowy, npts, fill)\n\
4446 \n\
4447 ARGUMENTS:\n\
4448 \n\
4449  arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n\
4450  containing the x and y points which make up the arrow. The arrow\n\
4451  is plotted by joining these points to form a polygon. The scaling\n\
4452  assumes that the x and y points in the arrow lie in the range -0.5\n\
4453  <= x,y <= 0.5. \n\
4454 \n\
4455  npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4456  arrowy. \n\
4457 \n\
4458  fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4459  fill is false then the arrow is open. \n\
4460 ";
4461 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
4462 Get family file parameters \n\
4463 \n\
4464 DESCRIPTION:\n\
4465 \n\
4466  Gets information about current family file, if familying is enabled. \n\
4467  See the PLplot documentation for more information. \n\
4468 \n\
4469  Redacted form: plgfam(fam, num, bmax)\n\
4470 \n\
4471  This function is used in examples 14,31. \n\
4472 \n\
4473 \n\
4474 \n\
4475 SYNOPSIS:\n\
4476 \n\
4477 plgfam(fam, num, bmax)\n\
4478 \n\
4479 ARGUMENTS:\n\
4480 \n\
4481  fam (PLINT *, output) : Pointer to variable with the Boolean family\n\
4482  flag value. If nonzero, familying is enabled. \n\
4483 \n\
4484  num (PLINT *, output) : Pointer to variable with the current family\n\
4485  file number. \n\
4486 \n\
4487  bmax (PLINT *, output) : Pointer to variable with the maximum file\n\
4488  size (in bytes) for a family file. \n\
4489 ";
4490 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
4491 Random number generator returning a real random number in the range [0,1]. \n\
4492 \n\
4493 DESCRIPTION:\n\
4494 \n\
4495  Random number generator returning a real random number in the range\n\
4496  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4497  / compilers provide their own random number generator, and so this is\n\
4498  provided purely for convenience and to give a consistent random number\n\
4499  generator across all languages supported by PLplot. This is\n\
4500  particularly useful for comparing results from the test suite of\n\
4501  examples. \n\
4502 \n\
4503  Redacted form: plrandd()\n\
4504 \n\
4505  This function is used in examples 17,21. \n\
4506 \n\
4507 \n\
4508 \n\
4509 SYNOPSIS:\n\
4510 \n\
4511 plrandd()\n\
4512 ";
4513 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
4514 Set line style \n\
4515 \n\
4516 DESCRIPTION:\n\
4517 \n\
4518  This sets up the line style for all lines subsequently drawn. A line\n\
4519  consists of segments in which the pen is alternately down and up. The\n\
4520  lengths of these segments are passed in the arrays mark and space\n\
4521  respectively. The number of mark-space pairs is specified by nels. \n\
4522  In order to return the line style to the default continuous line,\n\
4523  plstyl should be called with nels=0.(see also pllsty) \n\
4524 \n\
4525  Redacted form: plstyl(mark, space)\n\
4526 \n\
4527  This function is used in examples 1,9,14. \n\
4528 \n\
4529 \n\
4530 \n\
4531 SYNOPSIS:\n\
4532 \n\
4533 plstyl(nels, mark, space)\n\
4534 \n\
4535 ARGUMENTS:\n\
4536 \n\
4537  nels (PLINT, input) : The number of mark and space elements in a\n\
4538  line. Thus a simple broken line can be obtained by setting\n\
4539  nels=1. A continuous line is specified by setting nels=0. \n\
4540 \n\
4541  mark (PLINT *, input) : Pointer to array with the lengths of the\n\
4542  segments during which the pen is down, measured in micrometers. \n\
4543 \n\
4544  space (PLINT *, input) : Pointer to array with the lengths of the\n\
4545  segments during which the pen is up, measured in micrometers. \n\
4546 ";
4547 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
4548 Set the colors for color table 0 from a cmap0 file \n\
4549 \n\
4550 DESCRIPTION:\n\
4551 \n\
4552  Set the colors for color table 0 from a cmap0 file \n\
4553 \n\
4554  Redacted form: plspal0(filename)\n\
4555 \n\
4556  This function is in example 16. \n\
4557 \n\
4558 \n\
4559 \n\
4560 SYNOPSIS:\n\
4561 \n\
4562 plspal0(filename)\n\
4563 \n\
4564 ARGUMENTS:\n\
4565 \n\
4566  filename (const char *, input) : The name of the cmap0 file, or a\n\
4567  empty to string to specify the default cmap0 file. \n\
4568 ";
4569 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
4570 Set the colors for color table 1 from a cmap1 file \n\
4571 \n\
4572 DESCRIPTION:\n\
4573 \n\
4574  Set the colors for color table 1 from a cmap1 file \n\
4575 \n\
4576  Redacted form: plspal1(filename)\n\
4577 \n\
4578  This function is in example 16. \n\
4579 \n\
4580 \n\
4581 \n\
4582 SYNOPSIS:\n\
4583 \n\
4584 plspal1(filename)\n\
4585 \n\
4586 ARGUMENTS:\n\
4587 \n\
4588  filename (const char *, input) : The name of the cmap1 file, or a\n\
4589  empty to string to specify the default cmap1 file. \n\
4590 ";
4591 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
4592 Set current output stream \n\
4593 \n\
4594 DESCRIPTION:\n\
4595 \n\
4596  Sets the number of the current output stream. The stream number\n\
4597  defaults to 0 unless changed by this routine. The first use of this\n\
4598  routine must be followed by a call initializing PLplot (e.g. plstar). \n\
4599 \n\
4600  Redacted form: plsstrm(strm)\n\
4601 \n\
4602  This function is examples 1,14,20. \n\
4603 \n\
4604 \n\
4605 \n\
4606 SYNOPSIS:\n\
4607 \n\
4608 plsstrm(strm)\n\
4609 \n\
4610 ARGUMENTS:\n\
4611 \n\
4612  strm (PLINT, input) : The current stream number. \n\
4613 ";
4614 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4615 Specify viewport using coordinates \n\
4616 \n\
4617 DESCRIPTION:\n\
4618 \n\
4619  Device-independent routine for setting up the viewport. This defines\n\
4620  the viewport in terms of normalized subpage coordinates which run from\n\
4621  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4622  current subpage. Use the alternate routine plsvpa in order to create\n\
4623  a viewport of a definite size. \n\
4624 \n\
4625  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4626 \n\
4627  This function is used in examples\n\
4628  2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
4629 \n\
4630 \n\
4631 \n\
4632 SYNOPSIS:\n\
4633 \n\
4634 plvpor(xmin, xmax, ymin, ymax)\n\
4635 \n\
4636 ARGUMENTS:\n\
4637 \n\
4638  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4639  left-hand edge of the viewport. \n\
4640 \n\
4641  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4642  right-hand edge of the viewport. \n\
4643 \n\
4644  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4645  bottom edge of the viewport. \n\
4646 \n\
4647  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4648  edge of the viewport. \n\
4649 ";
4650 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
4651 Write text inside the viewport \n\
4652 \n\
4653 DESCRIPTION:\n\
4654 \n\
4655  Writes text at a specified position and inclination within the\n\
4656  viewport. Text is clipped at the viewport boundaries. The reference\n\
4657  point of a string lies along a line passing through the string at half\n\
4658  the height of a capital letter. The position of the reference point\n\
4659  along this line is determined by just, the reference point is placed\n\
4660  at world coordinates (\n\
4661  x, \n\
4662  y) within the viewport. The inclination of the string is specified in\n\
4663  terms of differences of world coordinates making it easy to write text\n\
4664  parallel to a line in a graph. \n\
4665 \n\
4666  Redacted form: plptex(x, y, dx, dy, just, text)\n\
4667 \n\
4668  This function is used in example 2-4,10,12-14,20,23,24,26. \n\
4669 \n\
4670 \n\
4671 \n\
4672 SYNOPSIS:\n\
4673 \n\
4674 plptex(x, y, dx, dy, just, text)\n\
4675 \n\
4676 ARGUMENTS:\n\
4677 \n\
4678  x (PLFLT, input) : x coordinate of reference point of string. \n\
4679 \n\
4680  y (PLFLT, input) : y coordinate of reference point of string. \n\
4681 \n\
4682  dx (PLFLT, input) : Together with dy, this specifies the\n\
4683  inclination of the string. The baseline of the string is parallel\n\
4684  to a line joining (\n\
4685  x, \n\
4686  y) to (\n\
4687  x+\n\
4688  dx, \n\
4689  y+\n\
4690  dy). \n\
4691 \n\
4692  dy (PLFLT, input) : Together with dx, this specifies the\n\
4693  inclination of the string. \n\
4694 \n\
4695  just (PLFLT, input) : Specifies the position of the string relative\n\
4696  to its reference point. If just=0., the reference point is at the\n\
4697  left and if just=1., it is at the right of the string. Other\n\
4698  values of just give intermediate justifications. \n\
4699 \n\
4700  text (const char *, input) : The string to be written out. \n\
4701 ";
4702 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
4703 Set z axis parameters \n\
4704 \n\
4705 DESCRIPTION:\n\
4706 \n\
4707  Identical to plsxax, except that arguments are flags for z axis. See\n\
4708  the description of plsxax for more detail. \n\
4709 \n\
4710  Redacted form: plszax(digmax, digits)\n\
4711 \n\
4712  This function is used in example 31. \n\
4713 \n\
4714 \n\
4715 \n\
4716 SYNOPSIS:\n\
4717 \n\
4718 plszax(digmax, digits)\n\
4719 \n\
4720 ARGUMENTS:\n\
4721 \n\
4722  digmax (PLINT, input) : Variable to set the maximum number of\n\
4723  digits for the z axis. If nonzero, the printed label will be\n\
4724  switched to a floating point representation when the number of\n\
4725  digits exceeds digmax. \n\
4726 \n\
4727  digits (PLINT, input) : Field digits value. Currently, changing\n\
4728  its value here has no effect since it is set only by plbox or\n\
4729  plbox3. However, the user may obtain its value after a call to\n\
4730  either of these functions by calling plgzax. \n\
4731 ";
4732 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
4733 Set character font \n\
4734 \n\
4735 DESCRIPTION:\n\
4736 \n\
4737  Sets the default character font for subsequent character drawing. Also\n\
4738  affects symbols produced by plpoin. This routine has no effect unless\n\
4739  the extended character set is loaded (see plfontld). \n\
4740 \n\
4741  Redacted form: plfont(font)\n\
4742 \n\
4743  This function is used in examples 1,2,4,7,13,24,26. \n\
4744 \n\
4745 \n\
4746 \n\
4747 SYNOPSIS:\n\
4748 \n\
4749 plfont(font)\n\
4750 \n\
4751 ARGUMENTS:\n\
4752 \n\
4753  font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
4754  and fastest) \n\
4755  2: Roman font \n\
4756  3: Italic font \n\
4757  4: Script font \n\
4758 ";
4759 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
4760 Draw a circular or elliptical arc \n\
4761 \n\
4762 DESCRIPTION:\n\
4763 \n\
4764  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
4765  semiminor axis b, starting at angle1 and ending at angle2. \n\
4766 \n\
4767  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
4768  fill)\n\
4769 \n\
4770 \n\
4771  This function is used in examples 3 and 27. \n\
4772 \n\
4773 \n\
4774 \n\
4775 SYNOPSIS:\n\
4776 \n\
4777 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
4778 \n\
4779 ARGUMENTS:\n\
4780 \n\
4781  x (PLFLT, input) : X coordinate of arc center. \n\
4782 \n\
4783  y (PLFLT, input) : Y coordinate of arc center. \n\
4784 \n\
4785  a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
4786 \n\
4787  b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
4788 \n\
4789  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
4790  semimajor axis. \n\
4791 \n\
4792  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
4793  semimajor axis. \n\
4794 \n\
4795  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
4796  X-axis. \n\
4797 \n\
4798  fill (PLBOOL, input) : Draw a filled arc. \n\
4799 ";
4800 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
4801 Set area fill pattern \n\
4802 \n\
4803 DESCRIPTION:\n\
4804 \n\
4805  Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
4806  parallel lines with specified inclinations and spacings. The\n\
4807  arguments to this routine are the number of sets to use (1 or 2)\n\
4808  followed by two pointers to integer arrays (of 1 or 2 elements)\n\
4809  specifying the inclinations in tenths of a degree and the spacing in\n\
4810  micrometers. (also see plpsty) \n\
4811 \n\
4812  Redacted form: General: plpat(inc, del)\n\
4813 \t Perl/PDL: plpat(nlin, inc, del)\n\
4814 \n\
4815 \n\
4816  This function is used in example 15. \n\
4817 \n\
4818 \n\
4819 \n\
4820 SYNOPSIS:\n\
4821 \n\
4822 plpat(nlin, inc, del)\n\
4823 \n\
4824 ARGUMENTS:\n\
4825 \n\
4826  nlin (PLINT, input) : Number of sets of lines making up the\n\
4827  pattern, either 1 or 2. \n\
4828 \n\
4829  inc (PLINT *, input) : Pointer to array with nlin elements.\n\
4830  Specifies the line inclination in tenths of a degree. (Should be\n\
4831  between -900 and 900). \n\
4832 \n\
4833  del (PLINT *, input) : Pointer to array with nlin elements.\n\
4834  Specifies the spacing in micrometers between the lines making up\n\
4835  the pattern. \n\
4836 ";
4837 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
4838 Get x axis parameters \n\
4839 \n\
4840 DESCRIPTION:\n\
4841 \n\
4842  Returns current values of the digmax and digits flags for the x axis. \n\
4843  digits is updated after the plot is drawn, so this routine should only\n\
4844  be called after the call to plbox (or plbox3) is complete.\tSee the\n\
4845  PLplot documentation for more information. \n\
4846 \n\
4847  Redacted form: plgxax(digmax, digits)\n\
4848 \n\
4849  This function is used in example 31. \n\
4850 \n\
4851 \n\
4852 \n\
4853 SYNOPSIS:\n\
4854 \n\
4855 plgxax(digmax, digits)\n\
4856 \n\
4857 ARGUMENTS:\n\
4858 \n\
4859  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
4860  number of digits for the x axis. If nonzero, the printed label\n\
4861  has been switched to a floating point representation when the\n\
4862  number of digits exceeds digmax. \n\
4863 \n\
4864  digits (PLINT *, output) : Pointer to variable with the actual\n\
4865  number of digits for the numeric labels (x axis) from the last\n\
4866  plot. \n\
4867 ";
4868 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
4869 Draw filled polygon in 3D \n\
4870 \n\
4871 DESCRIPTION:\n\
4872 \n\
4873  Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
4874  using the pattern defined by plpsty or plpat. The routine will\n\
4875  automatically close the polygon between the last and first vertices. \n\
4876  If multiple closed polygons are passed in x, y, and z then plfill3\n\
4877  will fill in between them. \n\
4878 \n\
4879  Redacted form: General: plfill3(x, y, z)\n\
4880 \t Perl/PDL: plfill3(n, x, y, z)\n\
4881 \n\
4882 \n\
4883  This function is used in example 15. \n\
4884 \n\
4885 \n\
4886 \n\
4887 SYNOPSIS:\n\
4888 \n\
4889 plfill3(n, x, y, z)\n\
4890 \n\
4891 ARGUMENTS:\n\
4892 \n\
4893  n (PLINT, input) : Number of vertices in polygon. \n\
4894 \n\
4895  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4896  vertices. \n\
4897 \n\
4898  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4899  vertices. \n\
4900 \n\
4901  z (PLFLT *, input) : Pointer to array with z coordinates of\n\
4902  vertices. \n\
4903 ";
4904 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
4905 Set color, map0 \n\
4906 \n\
4907 DESCRIPTION:\n\
4908 \n\
4909  Sets the color for color map0 (see the PLplot documentation). \n\
4910 \n\
4911  Redacted form: plcol0(color)\n\
4912 \n\
4913  This function is used in examples 1-9,11-16,18-27,29. \n\
4914 \n\
4915 \n\
4916 \n\
4917 SYNOPSIS:\n\
4918 \n\
4919 plcol0(color)\n\
4920 \n\
4921 ARGUMENTS:\n\
4922 \n\
4923  color (PLINT, input) : Integer representing the color. The\n\
4924  defaults at present are (these may change): \n\
4925  0 black (default background) \n\
4926  1 red (default foreground) \n\
4927  2 yellow \n\
4928  3 green \n\
4929  4 aquamarine \n\
4930  5 pink \n\
4931  6 wheat \n\
4932  7 grey \n\
4933  8 brown \n\
4934  9 blue \n\
4935  10 BlueViolet \n\
4936  11 cyan \n\
4937  12 turquoise \n\
4938  13 magenta \n\
4939  14 salmon \n\
4940  15 white \n\
4941 \n\
4942  Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
4943  change an individual color in the map0 color palette. \n\
4944 ";
4945 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
4946 Draw a line between two points \n\
4947 \n\
4948 DESCRIPTION:\n\
4949 \n\
4950  Joins the point (\n\
4951  x1, \n\
4952  y1) to (\n\
4953  x2, \n\
4954  y2). \n\
4955 \n\
4956  Redacted form: pljoin(x1,y1,x2,y2)\n\
4957 \n\
4958  This function is used in examples 3,14. \n\
4959 \n\
4960 \n\
4961 \n\
4962 SYNOPSIS:\n\
4963 \n\
4964 pljoin(x1, y1, x2, y2)\n\
4965 \n\
4966 ARGUMENTS:\n\
4967 \n\
4968  x1 (PLFLT, input) : x coordinate of first point. \n\
4969 \n\
4970  y1 (PLFLT, input) : y coordinate of first point. \n\
4971 \n\
4972  x2 (PLFLT, input) : x coordinate of second point. \n\
4973 \n\
4974  y2 (PLFLT, input) : y coordinate of second point. \n\
4975 ";
4976 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
4977 Set color, map1 \n\
4978 \n\
4979 DESCRIPTION:\n\
4980 \n\
4981  Sets the color for color map1 (see the PLplot documentation). \n\
4982 \n\
4983  Redacted form: plcol1(col1)\n\
4984 \n\
4985  This function is used in examples 12 and 21. \n\
4986 \n\
4987 \n\
4988 \n\
4989 SYNOPSIS:\n\
4990 \n\
4991 plcol1(col1)\n\
4992 \n\
4993 ARGUMENTS:\n\
4994 \n\
4995  col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
4996  and is mapped to color using the continuous map1 color palette\n\
4997  which by default ranges from blue to the background color to red. \n\
4998  The map1 palette can also be straightforwardly changed by the user\n\
4999  with plscmap1 or plscmap1l. \n\
5000 ";
5001 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
5002 Set orientation \n\
5003 \n\
5004 DESCRIPTION:\n\
5005 \n\
5006  Set integer plot orientation parameter. This function is identical to\n\
5007  plsdiori except for the type of the argument, and should be used in\n\
5008  the same way. See the PLplot documentation for details. \n\
5009 \n\
5010  Redacted form: plsori(ori)\n\
5011 \n\
5012  This function is used in example 3. \n\
5013 \n\
5014 \n\
5015 \n\
5016 SYNOPSIS:\n\
5017 \n\
5018 plsori(ori)\n\
5019 \n\
5020 ARGUMENTS:\n\
5021 \n\
5022  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5023  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5024  angle. \n\
5025 ";
5026 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5027 Plot continental outline in world coordinates. \n\
5028 \n\
5029 DESCRIPTION:\n\
5030 \n\
5031  Plots continental outlines in world coordinates. examples/c/x19c\n\
5032  demonstrates how to use this function to create different\n\
5033  projections. \n\
5034 \n\
5035  Redacted form: General: plmap(mapform, type, minlong, maxlong,\n\
5036  minlat, maxlat)\n\
5037 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
5038 \n\
5039 \n\
5040  This function is used in example 19. \n\
5041 \n\
5042 \n\
5043 \n\
5044 SYNOPSIS:\n\
5045 \n\
5046 plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n\
5047 \n\
5048 ARGUMENTS:\n\
5049 \n\
5050  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5051  supplied function to transform the coordinate longitudes and\n\
5052  latitudes to a plot coordinate system. By using this transform,\n\
5053  we can change from a longitude, latitude coordinate to a polar\n\
5054  stereographic project, for example. Initially, x[0]..[n-1] are\n\
5055  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5056  After the call to mapform(), x[] and y[] should be replaced by\n\
5057  the corresponding plot coordinates. If no transform is desired,\n\
5058  mapform can be replaced by NULL. \n\
5059 \n\
5060  type (char *, input) : type is a character string. The value of\n\
5061  this parameter determines the type of background. The possible\n\
5062  values are: \"globe\" -- continental outlines \n\
5063  \"usa\" -- USA and state boundaries \n\
5064  \"cglobe\" -- continental outlines and countries \n\
5065  \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5066 \n\
5067 \n\
5068  minlong (PLFLT, input) : The value of the longitude on the left\n\
5069  side of the plot. The value of minlong must be less than the\n\
5070  value of maxlong, and the quantity maxlong-minlong must be less\n\
5071  than or equal to 360. \n\
5072 \n\
5073  maxlong (PLFLT, input) : The value of the longitude on the right\n\
5074  side of the plot. \n\
5075 \n\
5076  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
5077  background. One can always use -90.0 as the boundary outside the\n\
5078  plot window will be automatically eliminated. However, the\n\
5079  program will be faster if one can reduce the size of the\n\
5080  background plotted. \n\
5081 \n\
5082  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
5083  background. One can always use 90.0 as the boundary outside the\n\
5084  plot window will be automatically eliminated. \n\
5085 ";
5086 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
5087 Get current stream number \n\
5088 \n\
5089 DESCRIPTION:\n\
5090 \n\
5091  Gets the number of the current output stream. See also plsstrm. \n\
5092 \n\
5093  Redacted form: plgstrm(strm)\n\
5094 \n\
5095  This function is used in example 1,20. \n\
5096 \n\
5097 \n\
5098 \n\
5099 SYNOPSIS:\n\
5100 \n\
5101 plgstrm(strm)\n\
5102 \n\
5103 ARGUMENTS:\n\
5104 \n\
5105  strm (PLINT *, output) : Pointer to current stream value. \n\
5106 ";
5107 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
5108 Draw a line in 3 space \n\
5109 \n\
5110 DESCRIPTION:\n\
5111 \n\
5112  Draws line in 3 space defined by n points in x, y, and z. You must\n\
5113  first set up the viewport, the 2d viewing window (in world\n\
5114  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
5115  more info. \n\
5116 \n\
5117  Redacted form: plline3(x, y, z)\n\
5118 \n\
5119  This function is used in example 18. \n\
5120 \n\
5121 \n\
5122 \n\
5123 SYNOPSIS:\n\
5124 \n\
5125 plline3(n, x, y, z)\n\
5126 \n\
5127 ARGUMENTS:\n\
5128 \n\
5129  n (PLINT, input) : Number of points defining line. \n\
5130 \n\
5131  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
5132 \n\
5133  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
5134 \n\
5135  z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
5136 ";
5137 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
5138 Load character font \n\
5139 \n\
5140 DESCRIPTION:\n\
5141 \n\
5142  Sets the character set to use for subsequent character drawing. May\n\
5143  be called before initializing PLplot. \n\
5144 \n\
5145  Redacted form: plfontld(set)\n\
5146 \n\
5147  This function is used in examples 1,7. \n\
5148 \n\
5149 \n\
5150 \n\
5151 SYNOPSIS:\n\
5152 \n\
5153 plfontld(set)\n\
5154 \n\
5155 ARGUMENTS:\n\
5156 \n\
5157  set (PLINT, input) : Specifies the character set to load: 0:\n\
5158  Standard character set \n\
5159  1: Extended character set \n\
5160 ";
5161 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
5162 Set any command-line option \n\
5163 \n\
5164 DESCRIPTION:\n\
5165 \n\
5166  Set any command-line option internally from a program before it\n\
5167  invokes plinit. opt is the name of the command-line option and optarg\n\
5168  is the corresponding command-line option argument.\t\n\
5169 \n\
5170  This function returns 0 on success. \n\
5171 \n\
5172  Redacted form: plsetopt(opt, optarg)\n\
5173 \n\
5174  This function is used in example 14. \n\
5175 \n\
5176 \n\
5177 \n\
5178 SYNOPSIS:\n\
5179 \n\
5180 int plsetopt(opt, optarg)\n\
5181 \n\
5182 ARGUMENTS:\n\
5183 \n\
5184  opt (const char *, input) : Pointer to string containing the\n\
5185  command-line option. \n\
5186 \n\
5187  optarg (const char *, input) : Pointer to string containing the\n\
5188  argument of the command-line option. \n\
5189 ";
5190 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
5191 Used to globally turn color output on/off \n\
5192 \n\
5193 DESCRIPTION:\n\
5194 \n\
5195  Used to globally turn color output on/off for those drivers/devices\n\
5196  that support it. \n\
5197 \n\
5198  Redacted form: plscolor(color)\n\
5199 \n\
5200  This function is used in example 31. \n\
5201 \n\
5202 \n\
5203 \n\
5204 SYNOPSIS:\n\
5205 \n\
5206 plscolor(color)\n\
5207 \n\
5208 ARGUMENTS:\n\
5209 \n\
5210  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
5211  turned off. If non-zero, color is turned on. \n\
5212 ";
5213 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
5214 Get the current device (keyword) name \n\
5215 \n\
5216 DESCRIPTION:\n\
5217 \n\
5218  Get the current device (keyword) name. Note: you must have allocated\n\
5219  space for this (80 characters is safe). \n\
5220 \n\
5221  Redacted form: plgdev(p_dev)\n\
5222 \n\
5223  This function is used in example 14. \n\
5224 \n\
5225 \n\
5226 \n\
5227 SYNOPSIS:\n\
5228 \n\
5229 plgdev(p_dev)\n\
5230 \n\
5231 ARGUMENTS:\n\
5232 \n\
5233  p_dev (char *, output) : Pointer to device (keyword) name string. \n\
5234 ";
5235 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
5236 Add a point to a stripchart \n\
5237 \n\
5238 DESCRIPTION:\n\
5239 \n\
5240  Add a point to a given pen of a given stripchart. There is no need for\n\
5241  all pens to have the same number of points or to be equally sampled in\n\
5242  the x coordinate. Allocates memory and rescales as necessary. \n\
5243 \n\
5244  Redacted form: plstripa(id, p, x, y)\n\
5245 \n\
5246  This function is used in example 17. \n\
5247 \n\
5248 \n\
5249 \n\
5250 SYNOPSIS:\n\
5251 \n\
5252 plstripa(id, p, x, y)\n\
5253 \n\
5254 ARGUMENTS:\n\
5255 \n\
5256  id (PLINT, input) : Identification number (set up in plstripc) of\n\
5257  the stripchart. \n\
5258 \n\
5259  p (PLINT, input) : Pen number (ranges from 0 to 3). \n\
5260 \n\
5261  x (PLFLT, input) : X coordinate of point to plot. \n\
5262 \n\
5263  y (PLFLT, input) : Y coordinate of point to plot. \n\
5264 ";
5265 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
5266 Deletes and releases memory used by a stripchart \n\
5267 \n\
5268 DESCRIPTION:\n\
5269 \n\
5270  Deletes and releases memory used by a stripchart. \n\
5271 \n\
5272  Redacted form: plstripd(id)\n\
5273 \n\
5274  This function is used in example 17. \n\
5275 \n\
5276 \n\
5277 \n\
5278 SYNOPSIS:\n\
5279 \n\
5280 plstripd(id)\n\
5281 \n\
5282 ARGUMENTS:\n\
5283 \n\
5284  id (PLINT, input) : Identification number of stripchart to delete. \n\
5285 ";
5286 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5287 Specify viewport using coordinates and aspect ratio \n\
5288 \n\
5289 DESCRIPTION:\n\
5290 \n\
5291  Device-independent routine for setting up the viewport. The viewport\n\
5292  is chosen to be the largest with the given aspect ratio that fits\n\
5293  within the specified region (in terms of normalized subpage\n\
5294  coordinates). This routine is functionally equivalent to plvpor when\n\
5295  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5296  routine reserves no extra space at the edges for labels. \n\
5297 \n\
5298  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5299 \n\
5300  This function is used in example 9. \n\
5301 \n\
5302 \n\
5303 \n\
5304 SYNOPSIS:\n\
5305 \n\
5306 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5307 \n\
5308 ARGUMENTS:\n\
5309 \n\
5310  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5311  left-hand edge of the viewport. \n\
5312 \n\
5313  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5314  right-hand edge of the viewport. \n\
5315 \n\
5316  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5317  bottom edge of the viewport. \n\
5318 \n\
5319  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5320  edge of the viewport. \n\
5321 \n\
5322  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5323  axis. \n\
5324 ";
5325 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
5326 Assign a function to use for generating custom axis labels \n\
5327 \n\
5328 DESCRIPTION:\n\
5329 \n\
5330  This function allows a user to provide their own function to provide\n\
5331  axis label text. The user function is given the numeric value for a\n\
5332  point on an axis and returns a string label to correspond with that\n\
5333  value. Custom axis labels can be enabled by passing appropriate\n\
5334  arguments to plenv, plbox, plbox3 and similar functions. \n\
5335 \n\
5336  This function is used in example 19. \n\
5337 \n\
5338 \n\
5339 \n\
5340 SYNOPSIS:\n\
5341 \n\
5342 plslabelfunc(label_func, label_data)\n\
5343 \n\
5344 ARGUMENTS:\n\
5345 \n\
5346  label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n\
5347  This is the custom label function. In order to reset to the\n\
5348  default labeling, set this to NULL. The labeling function\n\
5349  parameters are, in order: axis: This indicates which axis a\n\
5350  label is being requested for. The value will be one of PL_X_AXIS,\n\
5351  PL_Y_AXIS or PL_Z_AXIS. \n\
5352 \n\
5353  value: This is the value along the axis which is being labeled. \n\
5354 \n\
5355  label_text: The string representation of the label value. \n\
5356 \n\
5357  length: The maximum length in characters allowed for label_text. \n\
5358 \n\
5359 \n\
5360  label_data (void *, input) : This parameter may be used to pass\n\
5361  data to the label_func function. \n\
5362 ";
5363 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
5364 Set length of major ticks \n\
5365 \n\
5366 DESCRIPTION:\n\
5367 \n\
5368  This sets up the length of the major ticks. The actual length is the\n\
5369  product of the default length and a scaling factor as for character\n\
5370  height. \n\
5371 \n\
5372  Redacted form: plsmaj(def, scale)\n\
5373 \n\
5374  This function is used in example 29. \n\
5375 \n\
5376 \n\
5377 \n\
5378 SYNOPSIS:\n\
5379 \n\
5380 plsmaj(def, scale)\n\
5381 \n\
5382 ARGUMENTS:\n\
5383 \n\
5384  def (PLFLT, input) : The default length of a major tick in\n\
5385  millimeters, should be set to zero if the default length is to\n\
5386  remain unchanged. \n\
5387 \n\
5388  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
5389  actual tick length. \n\
5390 ";
5391 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
5392 Get the current library version number \n\
5393 \n\
5394 DESCRIPTION:\n\
5395 \n\
5396  Get the current library version number. Note: you must have allocated\n\
5397  space for this (80 characters is safe). \n\
5398 \n\
5399  Redacted form: plgver(p_ver)\n\
5400 \n\
5401  This function is used in example 1. \n\
5402 \n\
5403 \n\
5404 \n\
5405 SYNOPSIS:\n\
5406 \n\
5407 plgver(p_ver)\n\
5408 \n\
5409 ARGUMENTS:\n\
5410 \n\
5411  p_ver (char *, output) : Pointer to the current library version\n\
5412  number. \n\
5413 ";
5414 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
5415 Set format of numerical label for contours\n\
5416 \n\
5417 DESCRIPTION:\n\
5418 \n\
5419  Set format of numerical label for contours. \n\
5420 \n\
5421  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
5422 \n\
5423  This function is used example 9. \n\
5424 \n\
5425 \n\
5426 \n\
5427 SYNOPSIS:\n\
5428 \n\
5429 pl_setcontlabelformat(lexp, sigdig)\n\
5430 \n\
5431 ARGUMENTS:\n\
5432 \n\
5433  lexp (PLINT, input) : If the contour numerical label is greater\n\
5434  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
5435  format is used. Default value of lexp is 4. \n\
5436 \n\
5437  sigdig (PLINT, input) : Number of significant digits. Default\n\
5438  value is 2. \n\
5439 ";
5440 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
5441 Parse command-line arguments \n\
5442 \n\
5443 DESCRIPTION:\n\
5444 \n\
5445  Parse command-line arguments. \n\
5446 \n\
5447  plparseopts removes all recognized flags (decreasing argc\n\
5448  accordingly), so that invalid input may be readily detected. It can\n\
5449  also be used to process user command line flags. The user can merge\n\
5450  an option table of type PLOptionTable into the internal option table\n\
5451  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
5452  the external table(s) be parsed by calling plClearOpts before\n\
5453  plMergeOpts. \n\
5454 \n\
5455  The default action taken by plparseopts is as follows: \n\
5456  Returns with an error if an unrecognized option or badly formed\n\
5457  option-value pair are encountered.\t\n\
5458  Returns immediately (return code 0) when the first non-option command\n\
5459  line argument is found. \n\
5460  Returns with the return code of the option handler, if one was called.\n\
5461  \n\
5462  Deletes command line arguments from argv list as they are found, and\n\
5463  decrements argc accordingly. \n\
5464  Does not show \"invisible\" options in usage or help messages. \n\
5465  Assumes the program name is contained in argv[0]. \n\
5466 \n\
5467  These behaviors may be controlled through the \n\
5468  mode argument. \n\
5469 \n\
5470  Redacted form: General: plparseopts(argv, mode)\n\
5471 \t Perl/PDL: Not available? \n\
5472 \n\
5473 \n\
5474  This function is used in all of the examples. \n\
5475 \n\
5476 \n\
5477 \n\
5478 SYNOPSIS:\n\
5479 \n\
5480 int plparseopts(p_argc, argv, mode)\n\
5481 \n\
5482 ARGUMENTS:\n\
5483 \n\
5484  p_argc (int *, input) : pointer to number of arguments. \n\
5485 \n\
5486  argv (char **, input) : Pointer to character array containing\n\
5487  *p_argc command-line arguments. \n\
5488 \n\
5489  mode (PLINT, input) : Parsing mode with the following\n\
5490  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
5491  and all error messages enabled, including program exit when an\n\
5492  error occurs. Anything on the command line that isn\'t recognized\n\
5493  as a valid option or option argument is flagged as an error. \n\
5494  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
5495  of errors. \n\
5496  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
5497  arguments. \n\
5498  PL_PARSE_SHOWALL (8) -- Show invisible options \n\
5499  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
5500  pointer to the program name. \n\
5501  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
5502  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
5503  unrecognized arguments. \n\
5504 ";
5505 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
5506 Initialization \n\
5507 \n\
5508 DESCRIPTION:\n\
5509 \n\
5510  Initializing the plotting package.\tThe program prompts for the device\n\
5511  keyword or number of the desired output device. Hitting a RETURN in\n\
5512  response to the prompt is the same as selecting the first device. If\n\
5513  only one device is enabled when PLplot is installed, plstar will issue\n\
5514  no prompt.\tThe output device is divided into nx by ny subpages, each\n\
5515  of which may be used independently. The subroutine pladv is used to\n\
5516  advance from one subpage to the next. \n\
5517 \n\
5518  Redacted form: plstar(nx, ny)\n\
5519 \n\
5520  This function is used in example 1. \n\
5521 \n\
5522 \n\
5523 \n\
5524 SYNOPSIS:\n\
5525 \n\
5526 plstar(nx, ny)\n\
5527 \n\
5528 ARGUMENTS:\n\
5529 \n\
5530  nx (PLINT, input) : Number of subpages to divide output page in the\n\
5531  horizontal direction. \n\
5532 \n\
5533  ny (PLINT, input) : Number of subpages to divide output page in the\n\
5534  vertical direction. \n\
5535 ";
5536 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
5537 Get FCI (font characterization integer) \n\
5538 \n\
5539 DESCRIPTION:\n\
5540 \n\
5541  Gets information about the current font using the FCI approach. See\n\
5542  the PLplot documentation for more information. \n\
5543 \n\
5544  Redacted form: plgfci(fci)\n\
5545 \n\
5546  This function is used in example 23. \n\
5547 \n\
5548 \n\
5549 \n\
5550 SYNOPSIS:\n\
5551 \n\
5552 plgfci(fci)\n\
5553 \n\
5554 ARGUMENTS:\n\
5555 \n\
5556  fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
5557  integer) variable which is updated with current FCI value. \n\
5558 ";
5559 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
5560 Set family file parameters \n\
5561 \n\
5562 DESCRIPTION:\n\
5563 \n\
5564  Sets variables dealing with output file familying.\tDoes nothing if\n\
5565  familying not supported by the driver. This routine, if used, must be\n\
5566  called before initializing PLplot.\tSee the PLplot documentation for\n\
5567  more information. \n\
5568 \n\
5569  Redacted form: plsfam(fam, num, bmax)\n\
5570 \n\
5571  This function is used in examples 14,31. \n\
5572 \n\
5573 \n\
5574 \n\
5575 SYNOPSIS:\n\
5576 \n\
5577 plsfam(fam, num, bmax)\n\
5578 \n\
5579 ARGUMENTS:\n\
5580 \n\
5581  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
5582  is enabled. \n\
5583 \n\
5584  num (PLINT, input) : Current family file number. \n\
5585 \n\
5586  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
5587  file. \n\
5588 ";
5589 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
5590 Set color map1 colors using a piece-wise linear relationship \n\
5591 \n\
5592 DESCRIPTION:\n\
5593 \n\
5594  This is a version of plscmap1l that supports alpha transparency. It\n\
5595  sets color map1 colors using a piece-wise linear relationship between\n\
5596  position in the color map (from 0 to 1) and position in HLS or RGB\n\
5597  color space (see the PLplot documentation) with alpha value (0.0 -\n\
5598  1.0). It may be called at any time. \n\
5599 \n\
5600  This function is used in example 30. \n\
5601 \n\
5602 \n\
5603 \n\
5604 SYNOPSIS:\n\
5605 \n\
5606 plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n\
5607 \n\
5608 ARGUMENTS:\n\
5609 \n\
5610  itype (PLBOOL, input) : true: RGB, false: HLS. \n\
5611 \n\
5612  npts (PLINT, input) : number of control points \n\
5613 \n\
5614  pos (PLFLT *, input) : position for each control point (between 0.0\n\
5615  and 1.0, in ascending order) \n\
5616 \n\
5617  coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
5618  control point \n\
5619 \n\
5620  coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
5621  control point \n\
5622 \n\
5623  coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
5624  control point \n\
5625 \n\
5626  coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n\
5627  each control point \n\
5628 \n\
5629  alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
5630  flag for each control point. (alt_hue_path[i] refers to the\n\
5631  interpolation interval between the i and i + 1 control points). \n\
5632 ";
5633 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5634 Set page parameters \n\
5635 \n\
5636 DESCRIPTION:\n\
5637 \n\
5638  Sets the page configuration (optional). If an individual parameter is\n\
5639  zero then that parameter value is not updated. Not all parameters are\n\
5640  recognized by all drivers and the interpretation is device-dependent.\n\
5641  The X-window driver uses the length and offset parameters to determine\n\
5642  the window size and location. The length and offset values are\n\
5643  expressed in units that are specific to the current driver. For\n\
5644  instance: screen drivers will usually interpret them as number of\n\
5645  pixels, whereas printer drivers will usually use mm. This routine, if\n\
5646  used, must be called before initializing PLplot. \n\
5647 \n\
5648  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5649 \n\
5650  This function is used in examples 14 and 31. \n\
5651 \n\
5652 \n\
5653 \n\
5654 SYNOPSIS:\n\
5655 \n\
5656 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5657 \n\
5658 ARGUMENTS:\n\
5659 \n\
5660  xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
5661 \n\
5662  yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
5663 \n\
5664  xleng (PLINT , input) : Page length, x. \n\
5665 \n\
5666  yleng (PLINT, input) : Page length, y. \n\
5667 \n\
5668  xoff (PLINT, input) : Page offset, x. \n\
5669 \n\
5670  yoff (PLINT, input) : Page offset, y. \n\
5671 ";
5672 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
5673 Set precision in numeric labels \n\
5674 \n\
5675 DESCRIPTION:\n\
5676 \n\
5677  Sets the number of places after the decimal point in numeric labels. \n\
5678 \n\
5679  Redacted form: plprec(set, prec)\n\
5680 \n\
5681  This function is used in example 29. \n\
5682 \n\
5683 \n\
5684 \n\
5685 SYNOPSIS:\n\
5686 \n\
5687 plprec(set, prec)\n\
5688 \n\
5689 ARGUMENTS:\n\
5690 \n\
5691  set (PLINT, input) : If set is equal to 0 then PLplot automatically\n\
5692  determines the number of places to use after the decimal point in\n\
5693  numeric labels (like those used to label axes). If set is 1 then\n\
5694  prec sets the number of places. \n\
5695 \n\
5696  prec (PLINT, input) : The number of characters to draw after the\n\
5697  decimal point in numeric labels. \n\
5698 ";
5699 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5700 Copy state parameters from the reference stream to the current stream \n\
5701 \n\
5702 DESCRIPTION:\n\
5703 \n\
5704  Copies state parameters from the reference stream to the current\n\
5705  stream. Tell driver interface to map device coordinates unless flags\n\
5706  == 1. \n\
5707 \n\
5708  This function is used for making save files of selected plots (e.g.\n\
5709  from the TK driver). After initializing, you can get a copy of the\n\
5710  current plot to the specified device by switching to this stream and\n\
5711  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5712  appropriate. The plot buffer must have previously been enabled (done\n\
5713  automatically by some display drivers, such as X). \n\
5714 \n\
5715  Redacted form: plcpstrm(iplsr, flags)\n\
5716 \n\
5717  This function is used in example 1,20. \n\
5718 \n\
5719 \n\
5720 \n\
5721 SYNOPSIS:\n\
5722 \n\
5723 plcpstrm(iplsr, flags)\n\
5724 \n\
5725 ARGUMENTS:\n\
5726 \n\
5727  iplsr (PLINT, input) : Number of reference stream. \n\
5728 \n\
5729  flags (PLBOOL, input) : If flags is set to true the device\n\
5730  coordinates are not copied from the reference to current stream. \n\
5731 ";
5732 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
5733 Plot a glyph at the specified points \n\
5734 \n\
5735 DESCRIPTION:\n\
5736 \n\
5737  Plot a glyph at the specified points. (This function is largely\n\
5738  superseded by plstring which gives access to many[!] more glyphs.)\n\
5739  code=-1 means try to just draw a point. Right now it\'s just a move\n\
5740  and a draw at the same place. Not ideal, since a sufficiently\n\
5741  intelligent output device may optimize it away, or there may be faster\n\
5742  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5743  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5744  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5745  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5746  code <= 127 the corresponding printable ASCII character is plotted. \n\
5747 \n\
5748  Redacted form: plpoin(x, y, code)\n\
5749 \n\
5750  This function is used in examples 1,6,14,29. \n\
5751 \n\
5752 \n\
5753 \n\
5754 SYNOPSIS:\n\
5755 \n\
5756 plpoin(n, x, y, code)\n\
5757 \n\
5758 ARGUMENTS:\n\
5759 \n\
5760  n (PLINT, input) : Number of points in the x and y arrays. \n\
5761 \n\
5762  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
5763  points. \n\
5764 \n\
5765  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
5766  points. \n\
5767 \n\
5768  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5769  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5770  each of the n points. \n\
5771 ";
5772 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
5773 Enter or leave xor mode \n\
5774 \n\
5775 DESCRIPTION:\n\
5776 \n\
5777  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
5778  those drivers (e.g., the xwin driver) that support it. Enables\n\
5779  erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
5780  is not capable of xor operation it returns a status of false. \n\
5781 \n\
5782  Redacted form: plxormod(mode, status)\n\
5783 \n\
5784  This function is used in examples 1,20. \n\
5785 \n\
5786 \n\
5787 \n\
5788 SYNOPSIS:\n\
5789 \n\
5790 plxormod(mode, status)\n\
5791 \n\
5792 ARGUMENTS:\n\
5793 \n\
5794  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
5795  is false means leave xor mode. \n\
5796 \n\
5797  status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
5798  of true (false) means driver is capable (incapable) of xor mode. \n\
5799 ";
5800 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
5801 Get viewport limits in normalized device coordinates \n\
5802 \n\
5803 DESCRIPTION:\n\
5804 \n\
5805  Get viewport limits in normalized device coordinates. \n\
5806 \n\
5807  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5808 \t Perl/PDL: Not available? \n\
5809 \n\
5810 \n\
5811  This function is used in example 31. \n\
5812 \n\
5813 \n\
5814 \n\
5815 SYNOPSIS:\n\
5816 \n\
5817 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5818 \n\
5819 ARGUMENTS:\n\
5820 \n\
5821  p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5822  device coordinate in x. \n\
5823 \n\
5824  p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5825  device coordinate in x. \n\
5826 \n\
5827  p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5828  device coordinate in y. \n\
5829 \n\
5830  p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5831  device coordinate in y. \n\
5832 ";
5833 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
5834 End plotting session for current stream \n\
5835 \n\
5836 DESCRIPTION:\n\
5837 \n\
5838  Ends a plotting session for the current output stream only. See\n\
5839  plsstrm for more info. \n\
5840 \n\
5841  Redacted form: plend1()\n\
5842 \n\
5843  This function is used in examples 1,20. \n\
5844 \n\
5845 \n\
5846 \n\
5847 SYNOPSIS:\n\
5848 \n\
5849 plend1()\n\
5850 ";
5851 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
5852 Get y axis parameters \n\
5853 \n\
5854 DESCRIPTION:\n\
5855 \n\
5856  Identical to plgxax, except that arguments are flags for y axis. See\n\
5857  the description of plgxax for more detail. \n\
5858 \n\
5859  Redacted form: plgyax(digmax, digits)\n\
5860 \n\
5861  This function is used in example 31. \n\
5862 \n\
5863 \n\
5864 \n\
5865 SYNOPSIS:\n\
5866 \n\
5867 plgyax(digmax, digits)\n\
5868 \n\
5869 ARGUMENTS:\n\
5870 \n\
5871  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5872  number of digits for the y axis. If nonzero, the printed label\n\
5873  has been switched to a floating point representation when the\n\
5874  number of digits exceeds digmax. \n\
5875 \n\
5876  digits (PLINT *, output) : Pointer to variable with the actual\n\
5877  number of digits for the numeric labels (y axis) from the last\n\
5878  plot. \n\
5879 ";
5880 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
5881 Set plot orientation \n\
5882 \n\
5883 DESCRIPTION:\n\
5884 \n\
5885  Set plot orientation parameter which is multiplied by 90 degrees to\n\
5886  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
5887  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
5888  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
5889  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
5890  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
5891  not called the default value of rot is 0. \n\
5892 \n\
5893  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
5894  probably want to change the aspect ratio to a value suitable for the\n\
5895  plot orientation using a call to plsdidev or the command-line options\n\
5896  -a or -freeaspect.\tFor more documentation of those options see the\n\
5897  PLplot documentation. Such command-line options can be set internally\n\
5898  using plsetopt or set directly using the command line and parsed using\n\
5899  a call to plparseopts. \n\
5900 \n\
5901  Redacted form: plsdiori(rot)\n\
5902 \n\
5903  This function is not used in any examples. \n\
5904 \n\
5905 \n\
5906 \n\
5907 SYNOPSIS:\n\
5908 \n\
5909 plsdiori(rot)\n\
5910 \n\
5911 ARGUMENTS:\n\
5912 \n\
5913  rot (PLFLT, input) : Plot orientation parameter. \n\
5914 ";
5915 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
5916 Plot a histogram from unbinned data \n\
5917 \n\
5918 DESCRIPTION:\n\
5919 \n\
5920  Plots a histogram from n data points stored in the array data. This\n\
5921  routine bins the data into nbin bins equally spaced between datmin and\n\
5922  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
5923  opt allows, among other things, the histogram either to be plotted in\n\
5924  an existing window or causes plhist to call plenv with suitable limits\n\
5925  before plotting the histogram. \n\
5926 \n\
5927  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
5928 \n\
5929  This function is used in example 5. \n\
5930 \n\
5931 \n\
5932 \n\
5933 SYNOPSIS:\n\
5934 \n\
5935 plhist(n, data, datmin, datmax, nbin, opt)\n\
5936 \n\
5937 ARGUMENTS:\n\
5938 \n\
5939  n (PLINT, input) : Number of data points. \n\
5940 \n\
5941  data (PLFLT *, input) : Pointer to array with values of the n data\n\
5942  points. \n\
5943 \n\
5944  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
5945 \n\
5946  datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
5947 \n\
5948  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
5949  divide the interval xmin to xmax. \n\
5950 \n\
5951  opt (PLINT, input) : Is a combination of several flags:\n\
5952  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
5953  the histogram data, the outer bins are expanded to fill up the\n\
5954  entire x-axis, data outside the given extremes are assigned to the\n\
5955  outer bins and bins of zero height are simply drawn. \n\
5956  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
5957  to fit the histogram data, without this flag, plenv is called\n\
5958  to set the world coordinates. \n\
5959  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
5960  extremes are not taken into account. This option should\n\
5961  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
5962  properly present the data. \n\
5963  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
5964  size as the ones inside. \n\
5965  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
5966  (there is a gap for such bins). \n\
5967 ";
5968 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
5969 End plotting session \n\
5970 \n\
5971 DESCRIPTION:\n\
5972 \n\
5973  Ends a plotting session, tidies up all the output files, switches\n\
5974  interactive devices back into text mode and frees up any memory that\n\
5975  was allocated. Must be called before end of program. \n\
5976 \n\
5977  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
5978  wait state after a call to plend or other functions which trigger the\n\
5979  end of a plot page. To avoid this, use the plspause function. \n\
5980 \n\
5981  Redacted form: plend()\n\
5982 \n\
5983  This function is used in all of the examples. \n\
5984 \n\
5985 \n\
5986 \n\
5987 SYNOPSIS:\n\
5988 \n\
5989 plend()\n\
5990 ";
5991 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
5992 Set device-compression level \n\
5993 \n\
5994 DESCRIPTION:\n\
5995 \n\
5996  Set device-compression level. Only used for drivers that provide\n\
5997  compression. This function, if used, should be invoked before a call\n\
5998  to plinit.\t\n\
5999 \n\
6000  Redacted form: plscompression(compression)\n\
6001 \n\
6002  This function is used in example 31. \n\
6003 \n\
6004 \n\
6005 \n\
6006 SYNOPSIS:\n\
6007 \n\
6008 plscompression(compression)\n\
6009 \n\
6010 ARGUMENTS:\n\
6011 \n\
6012  compression (PLINT, input) : The desired compression level. This is\n\
6013  a device-dependent value. Currently only the jpeg and png devices\n\
6014  use these values. For jpeg value is the jpeg quality which should\n\
6015  normally be in the range 0-95. Higher values denote higher quality\n\
6016  and hence larger image sizes. For png values are in the range -1\n\
6017  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
6018  A value of -1 denotes the default zlib compression level. Values\n\
6019  in the range 10-99 are divided by 10 and then used as the zlib\n\
6020  compression level. Higher compression levels correspond to greater\n\
6021  compression and small file sizes at the expense of more\n\
6022  computation. \n\
6023 ";
6024 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
6025 Get the current device-compression setting \n\
6026 \n\
6027 DESCRIPTION:\n\
6028 \n\
6029  Get the current device-compression setting. This parameter is only\n\
6030  used for drivers that provide compression. \n\
6031 \n\
6032  Redacted form: plgcompression(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 plgcompression(compression)\n\
6041 \n\
6042 ARGUMENTS:\n\
6043 \n\
6044  compression (PLINT *, output) : Pointer to a variable to be filled\n\
6045  with the current device-compression setting. \n\
6046 ";
6047 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
6048 Advance the (sub-)page\n\
6049 \n\
6050 DESCRIPTION:\n\
6051 \n\
6052  Advances to the next subpage if sub=0, performing a page advance if\n\
6053  there are no remaining subpages on the current page. If subpages\n\
6054  aren\'t being used, pladv(0) will always advance the page. If sub>0,\n\
6055  PLplot switches to the specified subpage. Note that this allows you\n\
6056  to overwrite a plot on the specified subpage; if this is not what you\n\
6057  intended, use pleop followed by plbop to first advance the page. This\n\
6058  routine is called automatically (with sub=0) by plenv, but if plenv is\n\
6059  not used, pladv must be called after initializing PLplot but before\n\
6060  defining the viewport. \n\
6061 \n\
6062  Redacted form: pladv(sub)\n\
6063 \n\
6064  This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
6065 \n\
6066 \n\
6067 \n\
6068 SYNOPSIS:\n\
6069 \n\
6070 pladv(sub)\n\
6071 \n\
6072 ARGUMENTS:\n\
6073 \n\
6074  sub (PLINT, input) : Specifies the subpage number (starting from 1\n\
6075  in the top left corner and increasing along the rows) to which to\n\
6076  advance. Set to zero to advance to the next subpage. \n\
6077 ";
6078 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
6079 Set parameters of contour labelling other than format of numerical label\n\
6080 \n\
6081 DESCRIPTION:\n\
6082 \n\
6083  Set parameters of contour labelling other than those handled by\n\
6084  pl_setcontlabelformat. \n\
6085 \n\
6086  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
6087 \n\
6088  This function is used in example 9. \n\
6089 \n\
6090 \n\
6091 \n\
6092 SYNOPSIS:\n\
6093 \n\
6094 pl_setcontlabelparam(offset, size, spacing, active)\n\
6095 \n\
6096 ARGUMENTS:\n\
6097 \n\
6098  offset (PLFLT, input) : Offset of label from contour line (if set\n\
6099  to 0.0, labels are printed on the lines). Default value is 0.006. \n\
6100 \n\
6101  size (PLFLT, input) : Font height for contour labels (normalized). \n\
6102  Default value is 0.3. \n\
6103 \n\
6104  spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
6105  Default value is 0.1. \n\
6106 \n\
6107  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
6108  contour labels on. Default is off (0). \n\
6109 ";
6110 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
6111 Set family, style and weight of the current font \n\
6112 \n\
6113 DESCRIPTION:\n\
6114 \n\
6115  Sets the current font. See the PLplot documentation for more\n\
6116  information on font selection. \n\
6117 \n\
6118  Redacted form: plsfont(family, style, weight)\n\
6119 \n\
6120  This function is used in example 23. \n\
6121 \n\
6122 \n\
6123 \n\
6124 SYNOPSIS:\n\
6125 \n\
6126 plsfont(family, style, weight)\n\
6127 \n\
6128 ARGUMENTS:\n\
6129 \n\
6130  family (PLINT, input) : Font family to select for the current font.\n\
6131  The available values are given by the PL_FCI_* constants in\n\
6132  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n\
6133  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
6134  signifies that the font family should not be altered. \n\
6135 \n\
6136  style (PLINT, input) : Font style to select for the current font.\n\
6137  The available values are given by the PL_FCI_* constants in\n\
6138  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
6139  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
6140  should not be altered. \n\
6141 \n\
6142  weight (PLINT, input) : Font weight to select for the current font.\n\
6143  The available values are given by the PL_FCI_* constants in\n\
6144  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
6145  negative value signifies that the font weight should not be\n\
6146  altered. \n\
6147 ";
6148 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6149 Sets the 3D position of the light source \n\
6150 \n\
6151 DESCRIPTION:\n\
6152 \n\
6153  Sets the 3D position of the light source for use with plsurf3d. \n\
6154 \n\
6155  Redacted form: pllightsource(x, y, z)\n\
6156 \n\
6157  This function is used in example 8. \n\
6158 \n\
6159 \n\
6160 \n\
6161 SYNOPSIS:\n\
6162 \n\
6163 pllightsource(x, y, z)\n\
6164 \n\
6165 ARGUMENTS:\n\
6166 \n\
6167  x (PLFLT, input) : X-coordinate of the light source. \n\
6168 \n\
6169  y (PLFLT, input) : Y-coordinate of the light source. \n\
6170 \n\
6171  z (PLFLT, input) : Z-coordinate of the light source. \n\
6172 ";
6173 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
6174 Draw a line \n\
6175 \n\
6176 DESCRIPTION:\n\
6177 \n\
6178  Draws line defined by n points in x and y. \n\
6179 \n\
6180  Redacted form: plline(x, y)\n\
6181 \n\
6182  This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
6183 \n\
6184 \n\
6185 \n\
6186 SYNOPSIS:\n\
6187 \n\
6188 plline(n, x, y)\n\
6189 \n\
6190 ARGUMENTS:\n\
6191 \n\
6192  n (PLINT, input) : Number of points defining line. \n\
6193 \n\
6194  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
6195 \n\
6196  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
6197 ";
6198 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
6199 Set pen width \n\
6200 \n\
6201 DESCRIPTION:\n\
6202 \n\
6203  Sets the pen width. \n\
6204 \n\
6205  Redacted form: plwidth(width)\n\
6206 \n\
6207  This function is used in examples 1,2. \n\
6208 \n\
6209 \n\
6210 \n\
6211 SYNOPSIS:\n\
6212 \n\
6213 plwidth(width)\n\
6214 \n\
6215 ARGUMENTS:\n\
6216 \n\
6217  width (PLINT, input) : The desired pen width. If width is negative\n\
6218  or the same as the previous value no action is taken. width = 0\n\
6219  should be interpreted as as the minimum valid pen width for the\n\
6220  device. The interpretation of positive width values is also\n\
6221  device dependent. \n\
6222 ";
6223 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
6224 Draw linear gradient inside polygon \n\
6225 \n\
6226 DESCRIPTION:\n\
6227 \n\
6228  Draw a linear gradient using colour map 1 inside the polygon defined\n\
6229  by the n points (\n\
6230  x[i], \n\
6231  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
6232  polygon coordinates and the gradient angle are all expressed in world\n\
6233  coordinates. The angle from the x axis for both the rotated\n\
6234  coordinate system and the gradient vector is specified by angle. The\n\
6235  magnitude of the gradient vector is the difference between the maximum\n\
6236  and minimum values of x for the vertices in the rotated coordinate\n\
6237  system. The origin of the gradient vector can be interpreted as being\n\
6238  anywhere on the line corresponding to the minimum x value for the\n\
6239  vertices in the rotated coordinate system.\tThe distance along the\n\
6240  gradient vector is linearly transformed to the independent variable of\n\
6241  colour map 1 which ranges from 0. at the tail of the gradient vector\n\
6242  to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
6243  colour corresponding to the independent variable of colour map 1. For\n\
6244  more information about colour map 1 (see the PLplot documentation). \n\
6245 \n\
6246  Redacted form: plgradient(x,y,angle)\n\
6247 \n\
6248  This function is used in examples 25,30. \n\
6249 \n\
6250 \n\
6251 \n\
6252 SYNOPSIS:\n\
6253 \n\
6254 plgradient(n, x, y, angle)\n\
6255 \n\
6256 ARGUMENTS:\n\
6257 \n\
6258  n (PLINT, input) : Number of vertices in polygon. \n\
6259 \n\
6260  x (PLFLT *, input) : Pointer to array with x coordinates of\n\
6261  vertices. \n\
6262 \n\
6263  y (PLFLT *, input) : Pointer to array with y coordinates of\n\
6264  vertices. \n\
6265 \n\
6266  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
6267  axis. \n\
6268 ";
6269 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
6270 Flushes the output stream \n\
6271 \n\
6272 DESCRIPTION:\n\
6273 \n\
6274  Flushes the output stream. Use sparingly, if at all. \n\
6275 \n\
6276  Redacted form: plflush()\n\
6277 \n\
6278  This function is used in examples 1,14. \n\
6279 \n\
6280 \n\
6281 \n\
6282 SYNOPSIS:\n\
6283 \n\
6284 plflush()\n\
6285 ";
6286 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
6287 Get plot orientation \n\
6288 \n\
6289 DESCRIPTION:\n\
6290 \n\
6291  Get plot orientation parameter which is multiplied by 90 degrees to\n\
6292  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
6293  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
6294  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
6295  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
6296  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
6297  not been called the default value pointed to by p_rot will be 0. \n\
6298 \n\
6299  Redacted form: plgdiori(p_rot)\n\
6300 \n\
6301  This function is not used in any examples. \n\
6302 \n\
6303 \n\
6304 \n\
6305 SYNOPSIS:\n\
6306 \n\
6307 plgdiori(p_rot)\n\
6308 \n\
6309 ARGUMENTS:\n\
6310 \n\
6311  p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
6312 ";
6313 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
6314 Set x axis parameters \n\
6315 \n\
6316 DESCRIPTION:\n\
6317 \n\
6318  Sets values of the digmax and digits flags for the x axis.\tSee the\n\
6319  PLplot documentation for more information. \n\
6320 \n\
6321  Redacted form: plsxax(digmax, digits)\n\
6322 \n\
6323  This function is used in example 31. \n\
6324 \n\
6325 \n\
6326 \n\
6327 SYNOPSIS:\n\
6328 \n\
6329 plsxax(digmax, digits)\n\
6330 \n\
6331 ARGUMENTS:\n\
6332 \n\
6333  digmax (PLINT, input) : Variable to set the maximum number of\n\
6334  digits for the x axis. If nonzero, the printed label will be\n\
6335  switched to a floating point representation when the number of\n\
6336  digits exceeds digmax. \n\
6337 \n\
6338  digits (PLINT, input) : Field digits value. Currently, changing\n\
6339  its value here has no effect since it is set only by plbox or\n\
6340  plbox3. However, the user may obtain its value after a call to\n\
6341  either of these functions by calling plgxax. \n\
6342 ";
6343 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
6344 Get viewport limits in world coordinates \n\
6345 \n\
6346 DESCRIPTION:\n\
6347 \n\
6348  Get viewport limits in world coordinates. \n\
6349 \n\
6350  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6351 \t Perl/PDL: Not available? \n\
6352 \n\
6353 \n\
6354  This function is used in example 31. \n\
6355 \n\
6356 \n\
6357 \n\
6358 SYNOPSIS:\n\
6359 \n\
6360 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6361 \n\
6362 ARGUMENTS:\n\
6363 \n\
6364  p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
6365  coordinate in x. \n\
6366 \n\
6367  p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
6368  coordinate in x. \n\
6369 \n\
6370  p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
6371  coordinate in y. \n\
6372 \n\
6373  p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
6374  coordinate in y. \n\
6375 ";
6376 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
6377 Get current subpage parameters \n\
6378 \n\
6379 DESCRIPTION:\n\
6380 \n\
6381  Gets the size of the current subpage in millimeters measured from the\n\
6382  bottom left hand corner of the output device page or screen. Can be\n\
6383  used in conjunction with plsvpa for setting the size of a viewport in\n\
6384  absolute coordinates (millimeters). \n\
6385 \n\
6386  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
6387 \n\
6388  This function is used in example 23. \n\
6389 \n\
6390 \n\
6391 \n\
6392 SYNOPSIS:\n\
6393 \n\
6394 plgspa(xmin, xmax, ymin, ymax)\n\
6395 \n\
6396 ARGUMENTS:\n\
6397 \n\
6398  xmin (PLFLT *, output) : Pointer to variable with position of left\n\
6399  hand edge of subpage in millimeters. \n\
6400 \n\
6401  xmax (PLFLT *, output) : Pointer to variable with position of right\n\
6402  hand edge of subpage in millimeters. \n\
6403 \n\
6404  ymin (PLFLT *, output) : Pointer to variable with position of\n\
6405  bottom edge of subpage in millimeters. \n\
6406 \n\
6407  ymax (PLFLT *, output) : Pointer to variable with position of top\n\
6408  edge of subpage in millimeters. \n\
6409 ";
6410 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
6411 Calculate world coordinates and corresponding window index from relative device coordinates \n\
6412 \n\
6413 DESCRIPTION:\n\
6414 \n\
6415  Calculate world coordinates, wx and wy, and corresponding window index\n\
6416  from relative device coordinates, rx and ry. \n\
6417 \n\
6418  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
6419 \t Perl/PDL: Not available? \n\
6420 \n\
6421 \n\
6422  This function is used in example 31. \n\
6423 \n\
6424 \n\
6425 \n\
6426 SYNOPSIS:\n\
6427 \n\
6428 plcalc_world(rx, ry, wx, wy, window)\n\
6429 \n\
6430 ARGUMENTS:\n\
6431 \n\
6432  rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
6433  0. to 1.) for the x coordinate. \n\
6434 \n\
6435  ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
6436  0. to 1.) for the y coordinate. \n\
6437 \n\
6438  wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6439  x corresponding to the relative device coordinates rx and ry. \n\
6440 \n\
6441  wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6442  y corresponding to the relative device coordinates rx and ry. \n\
6443 \n\
6444  window (PLINT *, output) : Pointer to the returned last defined\n\
6445  window index that corresponds to the input relative device\n\
6446  coordinates (and the returned world coordinates). To give some\n\
6447  background on the window index, for each page the initial window\n\
6448  index is set to zero, and each time plwind is called within the\n\
6449  page, world and device coordinates are stored for the window and\n\
6450  the window index is incremented. Thus, for a simple page layout\n\
6451  with non-overlapping viewports and one window per viewport, window\n\
6452  corresponds to the viewport index (in the order which the\n\
6453  viewport/windows were created) of the only viewport/window\n\
6454  corresponding to rx and ry. However, for more complicated layouts\n\
6455  with potentially overlapping viewports and possibly more than one\n\
6456  window (set of world coordinates) per viewport, window and the\n\
6457  corresponding output world coordinates corresponds to the last\n\
6458  window created that fulfils the criterion that the relative device\n\
6459  coordinates are inside it. Finally, in all cases where the input\n\
6460  relative device coordinates are not inside any viewport/window,\n\
6461  then window is set to -1. \n\
6462 ";
6463 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6464 Draw a box with axes, etc, in 3-d \n\
6465 \n\
6466 DESCRIPTION:\n\
6467 \n\
6468  Draws axes, numeric and text labels for a three-dimensional surface\n\
6469  plot. For a more complete description of three-dimensional plotting\n\
6470  see the PLplot documentation. \n\
6471 \n\
6472  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6473  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6474 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
6475  xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
6476 \n\
6477 \n\
6478  This function is used in examples 8,11,18,21. \n\
6479 \n\
6480 \n\
6481 \n\
6482 SYNOPSIS:\n\
6483 \n\
6484 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6485 \n\
6486 ARGUMENTS:\n\
6487 \n\
6488  xopt (const char *, input) : Pointer to character string specifying\n\
6489  options for the x axis. The string can include any combination of\n\
6490  the following letters (upper or lower case) in any order: b: Draws\n\
6491  axis at base, at height z=\n\
6492  zmin where zmin is defined by call to plw3d. This character must be\n\
6493  specified in order to use any of the other options. \n\
6494  f: Always use fixed point numeric labels. \n\
6495  i: Inverts tick marks, so they are drawn downwards, rather\n\
6496  than upwards. \n\
6497  l: Labels axis logarithmically. This only affects the labels,\n\
6498  not the data, and so it is necessary to compute the logarithms\n\
6499  of data points before passing them to any of the drawing\n\
6500  routines. \n\
6501  n: Writes numeric labels at major tick intervals. \n\
6502  o: Use custom labeling function to generate axis label text. \n\
6503  The custom labeling function can be defined with the\n\
6504  plslabelfuncplslabelfunc; command. \n\
6505  s: Enables subticks between major ticks, only valid if t is\n\
6506  also specified. \n\
6507  t: Draws major ticks. \n\
6508  u: If this is specified, the text label for the axis is\n\
6509  written under the axis. \n\
6510 \n\
6511 \n\
6512  xlabel (const char *, input) : Pointer to character string\n\
6513  specifying text label for the x axis. It is only drawn if u is in\n\
6514  the xopt string. \n\
6515 \n\
6516  xtick (PLFLT, input) : World coordinate interval between major\n\
6517  ticks on the x axis. If it is set to zero, PLplot automatically\n\
6518  generates a suitable tick interval. \n\
6519 \n\
6520  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6521  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6522  generates a suitable minor tick interval. \n\
6523 \n\
6524  yopt (const char *, input) : Pointer to character string specifying\n\
6525  options for the y axis. The string is interpreted in the same way\n\
6526  as xopt. \n\
6527 \n\
6528  ylabel (const char *, input) : Pointer to character string\n\
6529  specifying text label for the y axis. It is only drawn if u is in\n\
6530  the yopt string. \n\
6531 \n\
6532  ytick (PLFLT, input) : World coordinate interval between major\n\
6533  ticks on the y axis. If it is set to zero, PLplot automatically\n\
6534  generates a suitable tick interval. \n\
6535 \n\
6536  nysub (PLINT, input) : Number of subintervals between major y axis\n\
6537  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6538  generates a suitable minor tick interval. \n\
6539 \n\
6540  zopt (const char *, input) : Pointer to character string specifying\n\
6541  options for the z axis. The string can include any combination of\n\
6542  the following letters (upper or lower case) in any order: b: Draws\n\
6543  z axis to the left of the surface plot. \n\
6544  c: Draws z axis to the right of the surface plot. \n\
6545  d: Draws grid lines parallel to the x-y plane behind the\n\
6546  figure. These lines are not drawn until after plot3d or\n\
6547  plmesh are called because of the need for hidden line removal. \n\
6548  f: Always use fixed point numeric labels. \n\
6549  i: Inverts tick marks, so they are drawn away from the center. \n\
6550  l: Labels axis logarithmically. This only affects the labels,\n\
6551  not the data, and so it is necessary to compute the logarithms\n\
6552  of data points before passing them to any of the drawing\n\
6553  routines. \n\
6554  m: Writes numeric labels at major tick intervals on the\n\
6555  right-hand vertical axis. \n\
6556  n: Writes numeric labels at major tick intervals on the\n\
6557  left-hand vertical axis. \n\
6558  o: Use custom labeling function to generate axis label text. \n\
6559  The custom labeling function can be defined with the\n\
6560  plslabelfuncplslabelfunc; command. \n\
6561  s: Enables subticks between major ticks, only valid if t is\n\
6562  also specified. \n\
6563  t: Draws major ticks. \n\
6564  u: If this is specified, the text label is written beside the\n\
6565  left-hand axis. \n\
6566  v: If this is specified, the text label is written beside the\n\
6567  right-hand axis. \n\
6568 \n\
6569 \n\
6570  zlabel (const char *, input) : Pointer to character string\n\
6571  specifying text label for the z axis. It is only drawn if u or v\n\
6572  are in the zopt string. \n\
6573 \n\
6574  ztick (PLFLT, input) : World coordinate interval between major\n\
6575  ticks on the z axis. If it is set to zero, PLplot automatically\n\
6576  generates a suitable tick interval. \n\
6577 \n\
6578  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6579  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6580  generates a suitable minor tick interval. \n\
6581 ";
6582 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
6583 Get character default height and current (scaled) height \n\
6584 \n\
6585 DESCRIPTION:\n\
6586 \n\
6587  Get character default height and current (scaled) height. \n\
6588 \n\
6589  Redacted form: plgchr(p_def, p_ht)\n\
6590 \n\
6591  This function is used in example 23. \n\
6592 \n\
6593 \n\
6594 \n\
6595 SYNOPSIS:\n\
6596 \n\
6597 plgchr(p_def, p_ht)\n\
6598 \n\
6599 ARGUMENTS:\n\
6600 \n\
6601  p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
6602 \n\
6603  p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
6604  height (mm). \n\
6605 ";
6606 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
6607 Set the escape character for text strings \n\
6608 \n\
6609 DESCRIPTION:\n\
6610 \n\
6611  Set the escape character for text strings.\tFrom C (in contrast to\n\
6612  Fortran 77, see plsescfortran77) you pass esc as a character. Only\n\
6613  selected characters are allowed to prevent the user from shooting\n\
6614  himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
6615  with C\'s use of backslash as a character escape). Here are the\n\
6616  allowed escape characters and their corresponding decimal ASCII\n\
6617  values: !, ASCII 33 \n\
6618 \t #, ASCII 35 \n\
6619 \t $, ASCII 36 \n\
6620 \t %, ASCII 37 \n\
6621 \t &, ASCII 38 \n\
6622 \t *, ASCII 42 \n\
6623 \t @, ASCII 64 \n\
6624 \t ^, ASCII 94 \n\
6625 \t ~, ASCII 126 \n\
6626 \n\
6627 \n\
6628  Redacted form: General: plsesc(esc)\n\
6629 \t Perl/PDL: Not available? \n\
6630 \n\
6631 \n\
6632  This function is used in example 29. \n\
6633 \n\
6634 \n\
6635 \n\
6636 SYNOPSIS:\n\
6637 \n\
6638 plsesc(esc)\n\
6639 \n\
6640 ARGUMENTS:\n\
6641 \n\
6642  esc (char, input) : Escape character. \n\
6643 ";
6644 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
6645 Set up standard window and draw box \n\
6646 \n\
6647 DESCRIPTION:\n\
6648 \n\
6649  Sets up plotter environment for simple graphs by calling pladv and\n\
6650  setting up viewport and window to sensible default values.\tplenv\n\
6651  leaves enough room around most graphs for axis labels and a title.\n\
6652  When these defaults are not suitable, use the individual routines\n\
6653  plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
6654  defining the window, and plbox for drawing the box. \n\
6655 \n\
6656  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6657 \n\
6658  This function is used in example 1,3,9,13,14,19-22,29. \n\
6659 \n\
6660 \n\
6661 \n\
6662 SYNOPSIS:\n\
6663 \n\
6664 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6665 \n\
6666 ARGUMENTS:\n\
6667 \n\
6668  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
6669  world coordinates). \n\
6670 \n\
6671  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
6672  world coordinates). \n\
6673 \n\
6674  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
6675  coordinates). \n\
6676 \n\
6677  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
6678  coordinates). \n\
6679 \n\
6680  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
6681  scales will not be set, the user must set up the scale before\n\
6682  calling plenv using plsvpa, plvasp or other. \n\
6683  0: the x and y axes are scaled independently to use as much of\n\
6684  the screen as possible. \n\
6685  1: the scales of the x and y axes are made equal. \n\
6686  2: the axis of the x and y axes are made equal, and the plot\n\
6687  box will be square. \n\
6688 \n\
6689 \n\
6690  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
6691  -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
6692  -1: draw box only. \n\
6693  0: draw box, ticks, and numeric tick labels. \n\
6694  1: also draw coordinate axes at x=0 and y=0. \n\
6695  2: also draw a grid at major tick positions in both\n\
6696  coordinates. \n\
6697  3: also draw a grid at minor tick positions in both\n\
6698  coordinates. \n\
6699  10: same as 0 except logarithmic x tick marks. (The x data\n\
6700  have to be converted to logarithms separately.) \n\
6701  11: same as 1 except logarithmic x tick marks. (The x data\n\
6702  have to be converted to logarithms separately.) \n\
6703  12: same as 2 except logarithmic x tick marks. (The x data\n\
6704  have to be converted to logarithms separately.) \n\
6705  13: same as 3 except logarithmic x tick marks. (The x data\n\
6706  have to be converted to logarithms separately.) \n\
6707  20: same as 0 except logarithmic y tick marks. (The y data\n\
6708  have to be converted to logarithms separately.) \n\
6709  21: same as 1 except logarithmic y tick marks. (The y data\n\
6710  have to be converted to logarithms separately.) \n\
6711  22: same as 2 except logarithmic y tick marks. (The y data\n\
6712  have to be converted to logarithms separately.) \n\
6713  23: same as 3 except logarithmic y tick marks. (The y data\n\
6714  have to be converted to logarithms separately.) \n\
6715  30: same as 0 except logarithmic x and y tick marks. (The x\n\
6716  and y data have to be converted to logarithms separately.) \n\
6717  31: same as 1 except logarithmic x and y tick marks. (The x\n\
6718  and y data have to be converted to logarithms separately.) \n\
6719  32: same as 2 except logarithmic x and y tick marks. (The x\n\
6720  and y data have to be converted to logarithms separately.) \n\
6721  33: same as 3 except logarithmic x and y tick marks. (The x\n\
6722  and y data have to be converted to logarithms separately.) \n\
6723  40: same as 0 except date / time x labels. \n\
6724  41: same as 1 except date / time x labels. \n\
6725  42: same as 2 except date / time x labels. \n\
6726  43: same as 3 except date / time x labels. \n\
6727  50: same as 0 except date / time y labels. \n\
6728  51: same as 1 except date / time y labels. \n\
6729  52: same as 2 except date / time y labels. \n\
6730  53: same as 3 except date / time y labels. \n\
6731  60: same as 0 except date / time x and y labels. \n\
6732  61: same as 1 except date / time x and y labels. \n\
6733  62: same as 2 except date / time x and y labels. \n\
6734  63: same as 3 except date / time x and y labels. \n\
6735  70: same as 0 except custom x and y labels. \n\
6736  71: same as 1 except custom x and y labels. \n\
6737  72: same as 2 except custom x and y labels. \n\
6738  73: same as 3 except custom x and y labels. \n\
6739 ";
6740 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
6741 Clear current (sub)page \n\
6742 \n\
6743 DESCRIPTION:\n\
6744 \n\
6745  Clears the current page, effectively erasing everything that have been\n\
6746  drawn. This command only works with interactive drivers; if the\n\
6747  driver does not support this, the page is filled with the background\n\
6748  color in use. If the current page is divided into subpages, only the\n\
6749  current subpage is erased.\tThe nth subpage can be selected with\n\
6750  pladv(n). \n\
6751 \n\
6752  Redacted form: General: plclear()\n\
6753 \t Perl/PDL: Not available? \n\
6754 \n\
6755 \n\
6756  This function is not used in any examples. \n\
6757 \n\
6758 \n\
6759 \n\
6760 SYNOPSIS:\n\
6761 \n\
6762 plclear()\n\
6763 ";
6764 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
6765 Set color map0 colors by 8-bit RGB values and double alpha value. \n\
6766 \n\
6767 DESCRIPTION:\n\
6768 \n\
6769  Set color map0 colors using 8-bit RGB values (see the PLplot\n\
6770  documentation) and floating point alpha value. This sets the entire\n\
6771  color map -- only as many colors as specified will be allocated. \n\
6772 \n\
6773  This function is used in examples 30. \n\
6774 \n\
6775 \n\
6776 \n\
6777 SYNOPSIS:\n\
6778 \n\
6779 plscmap0a(r, g, b, a, ncol0)\n\
6780 \n\
6781 ARGUMENTS:\n\
6782 \n\
6783  r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6784  integers (0-255) representing the degree of red in the color. \n\
6785 \n\
6786  g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6787  integers (0-255) representing the degree of green in the color. \n\
6788 \n\
6789  b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6790  integers (0-255) representing the degree of blue in the color. \n\
6791 \n\
6792  a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n\
6793  - 1.0) representing the transparency of the color. \n\
6794 \n\
6795  ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n\
6796  arrays. \n\
6797 ";
6798 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6799 Set a given color from color map0 by 8 bit RGB value \n\
6800 \n\
6801 DESCRIPTION:\n\
6802 \n\
6803  Set a given color by 8-bit RGB value for color map0 (see the PLplot\n\
6804  documentation). Overwrites the previous color value for the given\n\
6805  index and, thus, does not result in any additional allocation of space\n\
6806  for colors. \n\
6807 \n\
6808  Redacted form: plscol0(icol0, r, g, b)\n\
6809 \n\
6810  This function is not used in any examples. \n\
6811 \n\
6812 \n\
6813 \n\
6814 SYNOPSIS:\n\
6815 \n\
6816 plscol0(icol0, r, g, b)\n\
6817 \n\
6818 ARGUMENTS:\n\
6819 \n\
6820  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6821  number of colors (which is set by default, by plscmap0n, or even\n\
6822  by plscmap0). \n\
6823 \n\
6824  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6825  degree of red in the color. \n\
6826 \n\
6827  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6828  degree of green in the color. \n\
6829 \n\
6830  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6831  degree of blue in the color. \n\
6832 ";
6833 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
6834 Set up transformation from metafile coordinates \n\
6835 \n\
6836 DESCRIPTION:\n\
6837 \n\
6838  Set up transformation from metafile coordinates. The size of the plot\n\
6839  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
6840  general-purpose facility just yet (not sure why the user would need\n\
6841  it, for one). \n\
6842 \n\
6843  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
6844  dimypmm)\n\
6845 \n\
6846  This function is not used in any examples. \n\
6847 \n\
6848 \n\
6849 \n\
6850 SYNOPSIS:\n\
6851 \n\
6852 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
6853 \n\
6854 ARGUMENTS:\n\
6855 \n\
6856  dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
6857 \n\
6858  dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
6859 \n\
6860  dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
6861 \n\
6862  dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
6863 \n\
6864  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6865 \n\
6866  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6867 ";
6868 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6869 Creates a new stream and makes it the default \n\
6870 \n\
6871 DESCRIPTION:\n\
6872 \n\
6873  Creates a new stream and makes it the default. Differs from using\n\
6874  plsstrm, in that a free stream number is found, and returned.\n\
6875  Unfortunately, I have to start at stream 1 and work upward, since\n\
6876  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6877  that no initial, library-opening call is required.\tSo stream 0 must\n\
6878  be preallocated, and there is no simple way of determining whether it\n\
6879  is already in use or not. \n\
6880 \n\
6881  Redacted form: plmkstrm(p_strm)\n\
6882 \n\
6883  This function is used in examples 1,20. \n\
6884 \n\
6885 \n\
6886 \n\
6887 SYNOPSIS:\n\
6888 \n\
6889 plmkstrm(p_strm)\n\
6890 \n\
6891 ARGUMENTS:\n\
6892 \n\
6893  p_strm (PLINT *, output) : Pointer to stream number of the created\n\
6894  stream. \n\
6895 ";
6896 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
6897 Get page parameters \n\
6898 \n\
6899 DESCRIPTION:\n\
6900 \n\
6901  Gets the current page configuration. The length and offset values are\n\
6902  expressed in units that are specific to the current driver. For\n\
6903  instance: screen drivers will usually interpret them as number of\n\
6904  pixels, whereas printer drivers will usually use mm. \n\
6905 \n\
6906  Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6907 \n\
6908  This function is used in examples 14 and 31. \n\
6909 \n\
6910 \n\
6911 \n\
6912 SYNOPSIS:\n\
6913 \n\
6914 plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6915 \n\
6916 ARGUMENTS:\n\
6917 \n\
6918  xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
6919 \n\
6920  yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n\
6921 \n\
6922  xleng (PLINT *, output) : Pointer to x page length value. \n\
6923 \n\
6924  yleng (PLINT *, output) : Pointer to y page length value. \n\
6925 \n\
6926  xoff (PLINT *, output) : Pointer to x page offset. \n\
6927 \n\
6928  yoff (PLINT *, output) : Pointer to y page offset. \n\
6929 ";
6930 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
6931 Set format for date / time labels \n\
6932 \n\
6933 DESCRIPTION:\n\
6934 \n\
6935  Sets the format for date / time labels. To enable date / time format\n\
6936  labels see the options to plbox and plenv.\t\n\
6937 \n\
6938  Redacted form: pltimefmt(fmt)\n\
6939 \n\
6940  This function is used in example 29. \n\
6941 \n\
6942 \n\
6943 \n\
6944 SYNOPSIS:\n\
6945 \n\
6946 pltimefmt(fmt)\n\
6947 \n\
6948 ARGUMENTS:\n\
6949 \n\
6950  fmt (const char *, fmt) : This string is passed directly to the\n\
6951  system strftime. See the system documentation for a full list of\n\
6952  conversion specifications for your system. All conversion\n\
6953  specifications take the form of a \'%\' character followed by\n\
6954  further conversion specification character. All other text is\n\
6955  printed as-is. Common options include: %c: The preferred date and\n\
6956  time representation for the current locale. \n\
6957  %d: The day of the month as a decimal number. \n\
6958  %H: The hour as a decimal number using a 24-hour clock. \n\
6959  %j: The day of the year as a decimal number. \n\
6960  %m: The month as a decimal number. \n\
6961  %M: The minute as a decimal number. \n\
6962  %S: The second as a decimal number. \n\
6963  %y: The year as a decimal number without a century. \n\
6964  %Y: The year as a decimal number including a century. \n\
6965 ";
6966 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
6967 Specify viewport using aspect ratio only \n\
6968 \n\
6969 DESCRIPTION:\n\
6970 \n\
6971  Sets the viewport so that the ratio of the length of the y axis to\n\
6972  that of the x axis is equal to aspect. \n\
6973 \n\
6974  Redacted form: plvasp(aspect)\n\
6975 \n\
6976  This function is used in example 13. \n\
6977 \n\
6978 \n\
6979 \n\
6980 SYNOPSIS:\n\
6981 \n\
6982 plvasp(aspect)\n\
6983 \n\
6984 ARGUMENTS:\n\
6985 \n\
6986  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6987  axis. \n\
6988 ";
6989 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
6990 Set output file name \n\
6991 \n\
6992 DESCRIPTION:\n\
6993 \n\
6994  Sets the current output file name, if applicable. If the file name\n\
6995  has not been specified and is required by the driver, the user will be\n\
6996  prompted for it. If using the X-windows output driver, this sets the\n\
6997  display name. This routine, if used, must be called before\n\
6998  initializing PLplot. \n\
6999 \n\
7000  Redacted form: plsfnam(fnam)\n\
7001 \n\
7002  This function is used in examples 1,20. \n\
7003 \n\
7004 \n\
7005 \n\
7006 SYNOPSIS:\n\
7007 \n\
7008 plsfnam(fnam)\n\
7009 \n\
7010 ARGUMENTS:\n\
7011 \n\
7012  fnam (const char *, input) : Pointer to file name string. \n\
7013 ";
7014 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
7015 Set parameters that define current plot-space window \n\
7016 \n\
7017 DESCRIPTION:\n\
7018 \n\
7019  Set relative minima and maxima that define the current plot-space\n\
7020  window. If plsdiplt is not called the default values of xmin, ymin,\n\
7021  xmax, and ymax are 0., 0., 1., and 1. \n\
7022 \n\
7023  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
7024 \n\
7025  This function is used in example 31. \n\
7026 \n\
7027 \n\
7028 \n\
7029 SYNOPSIS:\n\
7030 \n\
7031 plsdiplt(xmin, ymin, xmax, ymax)\n\
7032 \n\
7033 ARGUMENTS:\n\
7034 \n\
7035  xmin (PLFLT, input) : Relative minimum in x. \n\
7036 \n\
7037  ymin (PLFLT, input) : Relative minimum in y. \n\
7038 \n\
7039  xmax (PLFLT, input) : Relative maximum in x. \n\
7040 \n\
7041  ymax (PLFLT, input) : Relative maximum in y. \n\
7042 ";
7043 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7044 Select line style \n\
7045 \n\
7046 DESCRIPTION:\n\
7047 \n\
7048  This sets the line style according to one of eight predefined patterns\n\
7049  (also see plstyl). \n\
7050 \n\
7051  Redacted form: pllsty(n)\n\
7052 \n\
7053  This function is used in examples 9,12,22,25. \n\
7054 \n\
7055 \n\
7056 \n\
7057 SYNOPSIS:\n\
7058 \n\
7059 pllsty(n)\n\
7060 \n\
7061 ARGUMENTS:\n\
7062 \n\
7063  n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n\
7064  continuous line, line style 2 is a line with short dashes and\n\
7065  gaps, line style 3 is a line with long dashes and gaps, line style\n\
7066  4 has long dashes and short gaps and so on. \n\
7067 ";
7068 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
7069 Plot a glyph at the specified points \n\
7070 \n\
7071 DESCRIPTION:\n\
7072 \n\
7073  Plot a glyph at the specified points. (This function is largely\n\
7074  superseded by plstring which gives access to many[!] more glyphs.) \n\
7075 \n\
7076  Redacted form: plsym(x, y, code)\n\
7077 \n\
7078  This function is used in example 7. \n\
7079 \n\
7080 \n\
7081 \n\
7082 SYNOPSIS:\n\
7083 \n\
7084 plsym(n, x, y, code)\n\
7085 \n\
7086 ARGUMENTS:\n\
7087 \n\
7088  n (PLINT, input) : Number of points in the x and y arrays. \n\
7089 \n\
7090  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7091  points. \n\
7092 \n\
7093  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7094  points. \n\
7095 \n\
7096  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
7097  to be plotted at each of the n points. \n\
7098 ";
7099 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7100 Set the device (keyword) name \n\
7101 \n\
7102 DESCRIPTION:\n\
7103 \n\
7104  Set the device (keyword) name. \n\
7105 \n\
7106  Redacted form: plsdev(devname)\n\
7107 \n\
7108  This function is used in examples 1,14,20. \n\
7109 \n\
7110 \n\
7111 \n\
7112 SYNOPSIS:\n\
7113 \n\
7114 plsdev(devname)\n\
7115 \n\
7116 ARGUMENTS:\n\
7117 \n\
7118  devname (const char *, input) : Pointer to device (keyword) name\n\
7119  string. \n\
7120 ";
7121 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
7122 Set the background color by 8-bit RGB value \n\
7123 \n\
7124 DESCRIPTION:\n\
7125 \n\
7126  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7127  (see the PLplot documentation). \n\
7128 \n\
7129  Redacted form: plscolbg(r, g, b)\n\
7130 \n\
7131  This function is used in examples 15,31. \n\
7132 \n\
7133 \n\
7134 \n\
7135 SYNOPSIS:\n\
7136 \n\
7137 plscolbg(r, g, b)\n\
7138 \n\
7139 ARGUMENTS:\n\
7140 \n\
7141  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7142  degree of red in the color. \n\
7143 \n\
7144  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7145  degree of green in the color. \n\
7146 \n\
7147  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7148  degree of blue in the color. \n\
7149 ";
7150 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
7151 Set parameters incrementally (zoom mode) that define current plot-space window \n\
7152 \n\
7153 DESCRIPTION:\n\
7154 \n\
7155  Set relative minima and maxima incrementally (zoom mode) that define\n\
7156  the current plot-space window. This function has the same effect as\n\
7157  plsdiplt if that function has not been previously called. Otherwise,\n\
7158  this function implements zoom mode using the transformation min_used =\n\
7159  old_min + old_length*min and max_used = old_min + old_length*max for\n\
7160  each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
7161  repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
7162 \n\
7163  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
7164 \n\
7165  This function is used in example 31. \n\
7166 \n\
7167 \n\
7168 \n\
7169 SYNOPSIS:\n\
7170 \n\
7171 plsdiplz(xmin, ymin, xmax, ymax)\n\
7172 \n\
7173 ARGUMENTS:\n\
7174 \n\
7175  xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
7176 \n\
7177  ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
7178 \n\
7179  xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
7180 \n\
7181  ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
7182 ";
7183 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
7184 Advance to the next family file on the next new page \n\
7185 \n\
7186 DESCRIPTION:\n\
7187 \n\
7188  Advance to the next family file on the next new page. \n\
7189 \n\
7190  Redacted form: plfamadv()\n\
7191 \n\
7192  This function is not used in any examples. \n\
7193 \n\
7194 \n\
7195 \n\
7196 SYNOPSIS:\n\
7197 \n\
7198 plfamadv()\n\
7199 ";
7200 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
7201 Set number of colors in color map0 \n\
7202 \n\
7203 DESCRIPTION:\n\
7204 \n\
7205  Set number of colors in color map0 (see the PLplot documentation).\n\
7206  Allocate (or reallocate) color map0, and fill with default values for\n\
7207  those colors not previously allocated. The first 16 default colors are\n\
7208  given in the plcol0 documentation. For larger indices the default\n\
7209  color is red. \n\
7210 \n\
7211  The drivers are not guaranteed to support more than 16 colors. \n\
7212 \n\
7213  Redacted form: plscmap0n(ncol0)\n\
7214 \n\
7215  This function is used in examples 15,16,24. \n\
7216 \n\
7217 \n\
7218 \n\
7219 SYNOPSIS:\n\
7220 \n\
7221 plscmap0n(ncol0)\n\
7222 \n\
7223 ARGUMENTS:\n\
7224 \n\
7225  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
7226  the map0 palette. If this number is zero or less, then the value\n\
7227  from the previous call to plscmap0n is used and if there is no\n\
7228  previous call, then a default value is used. \n\
7229 ";
7230 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
7231 Plot latitude and longitude lines. \n\
7232 \n\
7233 DESCRIPTION:\n\
7234 \n\
7235  Displays latitude and longitude on the current plot. The lines are\n\
7236  plotted in the current color and line style. \n\
7237 \n\
7238  Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n\
7239  maxlong, minlat, maxlat)\n\
7240 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
7241 \n\
7242 \n\
7243  This function is used in example 19. \n\
7244 \n\
7245 \n\
7246 \n\
7247 SYNOPSIS:\n\
7248 \n\
7249 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7250 \n\
7251 ARGUMENTS:\n\
7252 \n\
7253  mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
7254  supplied function to transform the coordinate longitudes and\n\
7255  latitudes to a plot coordinate system. By using this transform,\n\
7256  we can change from a longitude, latitude coordinate to a polar\n\
7257  stereographic project, for example. Initially, x[0]..[n-1] are\n\
7258  the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
7259  After the call to mapform(), x[] and y[] should be replaced by\n\
7260  the corresponding plot coordinates. If no transform is desired,\n\
7261  mapform can be replaced by NULL. \n\
7262 \n\
7263  dlong (PLFLT, input) : The interval in degrees at which the\n\
7264  longitude lines are to be plotted. \n\
7265 \n\
7266  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7267  lines are to be plotted. \n\
7268 \n\
7269  minlong (PLFLT, input) : The value of the longitude on the left\n\
7270  side of the plot. The value of minlong must be less than the\n\
7271  value of maxlong, and the quantity maxlong-minlong must be less\n\
7272  than or equal to 360. \n\
7273 \n\
7274  maxlong (PLFLT, input) : The value of the longitude on the right\n\
7275  side of the plot. \n\
7276 \n\
7277  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7278  background. One can always use -90.0 as the boundary outside the\n\
7279  plot window will be automatically eliminated. However, the\n\
7280  program will be faster if one can reduce the size of the\n\
7281  background plotted. \n\
7282 \n\
7283  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7284  background. One can always use 90.0 as the boundary outside the\n\
7285  plot window will be automatically eliminated. \n\
7286 ";
7287 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
7288 Convert RGB color to HLS \n\
7289 \n\
7290 DESCRIPTION:\n\
7291 \n\
7292  Convert RGB color coordinates to HLS \n\
7293 \n\
7294  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7295 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
7296 \n\
7297 \n\
7298  This function is used in example 2. \n\
7299 \n\
7300 \n\
7301 \n\
7302 SYNOPSIS:\n\
7303 \n\
7304 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7305 \n\
7306 ARGUMENTS:\n\
7307 \n\
7308  r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
7309 \n\
7310  g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
7311 \n\
7312  b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
7313 \n\
7314  p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
7315  cone (0.0-360.0) \n\
7316 \n\
7317  p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
7318  fraction of the axis of the colour cone (0.0-1.0) \n\
7319 \n\
7320  p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
7321  fraction of the radius of the colour cone (0.0-1.0) \n\
7322 ";
7323 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
7324 Plot a glyph at the specified 3D points \n\
7325 \n\
7326 DESCRIPTION:\n\
7327 \n\
7328  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
7329  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
7330  this function similar to what is done for plline3. The glyph is\n\
7331  specified with a PLplot user string. Note that the user string is not\n\
7332  actually limited to one glyph so it is possible (but not normally\n\
7333  useful) to plot more than one glyph at the specified points with this\n\
7334  function. As with plmtex and plptex, the user string can contain FCI\n\
7335  escapes to determine the font, UTF-8 code to determine the glyph or\n\
7336  else PLplot escapes for Hershey or unicode text to determine the\n\
7337  glyph. \n\
7338 \n\
7339  Redacted form: plstring3(x, y, z, string)\n\
7340 \n\
7341  This function is used in example 18. \n\
7342 \n\
7343 \n\
7344 \n\
7345 SYNOPSIS:\n\
7346 \n\
7347 plstring3(n, x, y, z, string)\n\
7348 \n\
7349 ARGUMENTS:\n\
7350 \n\
7351  n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
7352 \n\
7353  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7354  points. \n\
7355 \n\
7356  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7357  points. \n\
7358 \n\
7359  z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7360  points. \n\
7361 \n\
7362  string (const char *, input) : PLplot user string corresponding to\n\
7363  the glyph to be plotted at each of the n points. \n\
7364 ";
7365 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7366 Switch to text screen \n\
7367 \n\
7368 DESCRIPTION:\n\
7369 \n\
7370  Sets an interactive device to text mode, used in conjunction with\n\
7371  plgra to allow graphics and text to be interspersed. On a device\n\
7372  which supports separate text and graphics windows, this command causes\n\
7373  control to be switched to the text window.\tThis can be useful for\n\
7374  printing diagnostic messages or getting user input, which would\n\
7375  otherwise interfere with the plots. The program must switch back to\n\
7376  the graphics window before issuing plot commands, as the text (or\n\
7377  console) device will probably become quite confused otherwise. If\n\
7378  already in text mode, this command is ignored. It is also ignored on\n\
7379  devices which only support a single window or use a different method\n\
7380  for shifting focus (see also plgra). \n\
7381 \n\
7382  Redacted form: pltext()\n\
7383 \n\
7384  This function is used in example 1. \n\
7385 \n\
7386 \n\
7387 \n\
7388 SYNOPSIS:\n\
7389 \n\
7390 pltext()\n\
7391 ";
7392 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
7393 Get parameters that define current plot-space window \n\
7394 \n\
7395 DESCRIPTION:\n\
7396 \n\
7397  Get relative minima and maxima that define current plot-space window.\n\
7398  If plsdiplt has not been called the default values pointed to by\n\
7399  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
7400 \n\
7401  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7402 \n\
7403  This function is used in example 31. \n\
7404 \n\
7405 \n\
7406 \n\
7407 SYNOPSIS:\n\
7408 \n\
7409 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7410 \n\
7411 ARGUMENTS:\n\
7412 \n\
7413  p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
7414 \n\
7415  p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
7416 \n\
7417  p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
7418 \n\
7419  p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
7420 ";
7421 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7422 Get the (current) run level \n\
7423 \n\
7424 DESCRIPTION:\n\
7425 \n\
7426  Get the (current) run level. Valid settings are: 0, uninitialized \n\
7427 \t 1,\tinitialized \n\
7428 \t 2,\tviewport defined \n\
7429 \t 3,\tworld coordinates defined \n\
7430 \n\
7431 \n\
7432  Redacted form: plglevel(p_level)\n\
7433 \n\
7434  This function is used in example 31. \n\
7435 \n\
7436 \n\
7437 \n\
7438 SYNOPSIS:\n\
7439 \n\
7440 plglevel(p_level)\n\
7441 \n\
7442 ARGUMENTS:\n\
7443 \n\
7444  p_level (PLINT *, output) : Pointer to the run level. \n\
7445 ";
7446 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
7447 Plot a histogram from binned data \n\
7448 \n\
7449 DESCRIPTION:\n\
7450 \n\
7451  Plots a histogram consisting of nbin bins.\tThe value associated with\n\
7452  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
7453  placed in y[i]. For proper operation, the values in x[i] must form a\n\
7454  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
7455  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
7456  placed midway between the values in the x array. Also see plhist for\n\
7457  drawing histograms from unbinned data. \n\
7458 \n\
7459  Redacted form: General: plbin(x, y, opt)\n\
7460 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
7461 \t Python: plbin(nbin, x, y, opt)\n\
7462 \n\
7463 \n\
7464  This function is not used in any examples. \n\
7465 \n\
7466 \n\
7467 \n\
7468 SYNOPSIS:\n\
7469 \n\
7470 plbin(nbin, x, y, opt)\n\
7471 \n\
7472 ARGUMENTS:\n\
7473 \n\
7474  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
7475  and y arrays.) \n\
7476 \n\
7477  x (PLFLT *, input) : Pointer to array containing values associated\n\
7478  with bins. These must form a strictly increasing sequence. \n\
7479 \n\
7480  y (PLFLT *, input) : Pointer to array containing number of points\n\
7481  in bin. This is a PLFLT (instead of PLINT) array so as to allow\n\
7482  histograms of probabilities, etc. \n\
7483 \n\
7484  opt (PLINT, input) : Is a combination of several flags:\n\
7485  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
7486  outer bins are expanded to fill up the entire x-axis and bins of\n\
7487  zero height are simply drawn. \n\
7488  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
7489  between the x values. If the values in x are equally spaced,\n\
7490  the values are the center values of the bins. \n\
7491  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
7492  size as the ones inside. \n\
7493  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
7494  (there is a gap for such bins). \n\
7495 ";
7496 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7497 Get family, style and weight of the current font \n\
7498 \n\
7499 DESCRIPTION:\n\
7500 \n\
7501  Gets information about current font. See the PLplot documentation for\n\
7502  more information on font selection. \n\
7503 \n\
7504  Redacted form: plgfont(p_family, p_style, p_weight)\n\
7505 \n\
7506  This function is used in example 23. \n\
7507 \n\
7508 \n\
7509 \n\
7510 SYNOPSIS:\n\
7511 \n\
7512 plgfont(p_family, p_style, p_weight)\n\
7513 \n\
7514 ARGUMENTS:\n\
7515 \n\
7516  p_family (PLINT *, output) : Pointer to variable with the current\n\
7517  font family. The available values are given by the PL_FCI_*\n\
7518  constants in plplot.h. Current options are PL_FCI_SANS,\n\
7519  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7520  p_family is NULL then the font family is not returned. \n\
7521 \n\
7522  p_style (PLINT *, output) : Pointer to variable with the current\n\
7523  font style. The available values are given by the PL_FCI_*\n\
7524  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7525  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
7526  font style is not returned. \n\
7527 \n\
7528  p_weight (PLINT *, output) : Pointer to variable with the current\n\
7529  font weight. The available values are given by the PL_FCI_*\n\
7530  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7531  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7532  returned. \n\
7533 ";
7534 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
7535 Get z axis parameters \n\
7536 \n\
7537 DESCRIPTION:\n\
7538 \n\
7539  Identical to plgxax, except that arguments are flags for z axis. See\n\
7540  the description of plgxax for more detail. \n\
7541 \n\
7542  Redacted form: plgzax(digmax, digits)\n\
7543 \n\
7544  This function is used in example 31. \n\
7545 \n\
7546 \n\
7547 \n\
7548 SYNOPSIS:\n\
7549 \n\
7550 plgzax(digmax, digits)\n\
7551 \n\
7552 ARGUMENTS:\n\
7553 \n\
7554  digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7555  number of digits for the z axis. If nonzero, the printed label\n\
7556  has been switched to a floating point representation when the\n\
7557  number of digits exceeds digmax. \n\
7558 \n\
7559  digits (PLINT *, output) : Pointer to variable with the actual\n\
7560  number of digits for the numeric labels (z axis) from the last\n\
7561  plot. \n\
7562 ";
7563 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
7564 Write text inside the viewport of a 3D plot. \n\
7565 \n\
7566 DESCRIPTION:\n\
7567 \n\
7568  Writes text at a specified position and inclination and with a\n\
7569  specified shear within the viewport. Text is clipped at the viewport\n\
7570  boundaries. The reference point of a string lies along a line passing\n\
7571  through the string at half the height of a capital letter.\tThe\n\
7572  position of the reference point along this line is determined by just,\n\
7573  and the reference point is placed at world coordinates (\n\
7574  x, \n\
7575  y, \n\
7576  z) within the viewport. The inclination and shear of the string is\n\
7577  specified in terms of differences of world coordinates making it easy\n\
7578  to write text parallel to a line in a graph. \n\
7579 \n\
7580  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7581 \n\
7582  This function is used in example 28. \n\
7583 \n\
7584 \n\
7585 \n\
7586 SYNOPSIS:\n\
7587 \n\
7588 plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7589 \n\
7590 ARGUMENTS:\n\
7591 \n\
7592  x (PLFLT, input) : x coordinate of reference point of string. \n\
7593 \n\
7594  y (PLFLT, input) : y coordinate of reference point of string. \n\
7595 \n\
7596  z (PLFLT, input) : z coordinate of reference point of string. \n\
7597 \n\
7598  dx (PLFLT, input) : Together with dy and \n\
7599  dz, this specifies the inclination of the string. The baseline of\n\
7600  the string is parallel to a line joining (\n\
7601  x, \n\
7602  y, \n\
7603  z) to (\n\
7604  x+\n\
7605  dx, \n\
7606  y+\n\
7607  dy, \n\
7608  z+\n\
7609  dz). \n\
7610 \n\
7611  dy (PLFLT, input) : Together with dx and \n\
7612  dz, this specifies the inclination of the string. \n\
7613 \n\
7614  dz (PLFLT, input) : Together with dx and \n\
7615  dy, this specifies the inclination of the string. \n\
7616 \n\
7617  sx (PLFLT, input) : Together with sy and \n\
7618  sz, this specifies the shear of the string. The string is sheared so\n\
7619  that the characters are vertically parallel to a line joining (\n\
7620  x, \n\
7621  y, \n\
7622  z) to (\n\
7623  x+\n\
7624  sx, \n\
7625  y+\n\
7626  sy, \n\
7627  z+\n\
7628  sz). If sx = \n\
7629  sy = \n\
7630  sz = 0.) then the text is not sheared. \n\
7631 \n\
7632  sy (PLFLT, input) : Together with sx and \n\
7633  sz, this specifies shear of the string. \n\
7634 \n\
7635  sz (PLFLT, input) : Together with sx and \n\
7636  sy, this specifies shear of the string. \n\
7637 \n\
7638  just (PLFLT, input) : Specifies the position of the string relative\n\
7639  to its reference point. If just=0., the reference point is at the\n\
7640  left and if just=1., it is at the right of the string. Other\n\
7641  values of just give intermediate justifications. \n\
7642 \n\
7643  text (const char *, input) : The string to be written out. \n\
7644 ";
7645 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
7646 Draw a box with axes, etc. with arbitrary origin \n\
7647 \n\
7648 DESCRIPTION:\n\
7649 \n\
7650  Draws a box around the currently defined viewport with arbitrary\n\
7651  world-coordinate origin specified by x0 and y0 and labels it with\n\
7652  world coordinate values appropriate to the window.\tThus plaxes should\n\
7653  only be called after defining both viewport and window. The character\n\
7654  strings xopt and yopt specify how the box should be drawn as described\n\
7655  below. If ticks and/or subticks are to be drawn for a particular\n\
7656  axis, the tick intervals and number of subintervals may be specified\n\
7657  explicitly, or they may be defaulted by setting the appropriate\n\
7658  arguments to zero. \n\
7659 \n\
7660  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
7661  ytick, nysub)\n\
7662 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
7663  yopt)\n\
7664 \n\
7665 \n\
7666  This function is not used in any examples. \n\
7667 \n\
7668 \n\
7669 \n\
7670 SYNOPSIS:\n\
7671 \n\
7672 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
7673 \n\
7674 ARGUMENTS:\n\
7675 \n\
7676  x0 (PLFLT, input) : World X coordinate of origin. \n\
7677 \n\
7678  y0 (PLFLT, input) : World Y coordinate of origin. \n\
7679 \n\
7680  xopt (const char *, input) : Pointer to character string specifying\n\
7681  options for horizontal axis. The string can include any\n\
7682  combination of the following letters (upper or lower case) in any\n\
7683  order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
7684  is vertical line (x=0). \n\
7685  b: Draws bottom (X) or left (Y) edge of frame. \n\
7686  c: Draws top (X) or right (Y) edge of frame. \n\
7687  d: Plot labels as date / time. Values are assumed to be\n\
7688  seconds since the epoch (as used by gmtime). \n\
7689  f: Always use fixed point numeric labels. \n\
7690  g: Draws a grid at the major tick interval. \n\
7691  h: Draws a grid at the minor tick interval. \n\
7692  i: Inverts tick marks, so they are drawn outwards, rather than\n\
7693  inwards. \n\
7694  l: Labels axis logarithmically. This only affects the labels,\n\
7695  not the data, and so it is necessary to compute the logarithms\n\
7696  of data points before passing them to any of the drawing\n\
7697  routines. \n\
7698  m: Writes numeric labels at major tick intervals in the\n\
7699  unconventional location (above box for X, right of box for Y). \n\
7700  n: Writes numeric labels at major tick intervals in the\n\
7701  conventional location (below box for X, left of box for Y). \n\
7702  o: Use custom labeling function to generate axis label text. \n\
7703  The custom labeling function can be defined with the\n\
7704  plslabelfuncplslabelfunc; command. \n\
7705  s: Enables subticks between major ticks, only valid if t is\n\
7706  also specified. \n\
7707  t: Draws major ticks. \n\
7708 \n\
7709 \n\
7710  xtick (PLFLT, input) : World coordinate interval between major\n\
7711  ticks on the x axis. If it is set to zero, PLplot automatically\n\
7712  generates a suitable tick interval. \n\
7713 \n\
7714  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
7715  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7716  generates a suitable minor tick interval. \n\
7717 \n\
7718  yopt (const char *, input) : Pointer to character string specifying\n\
7719  options for vertical axis. The string can include any combination\n\
7720  of the letters defined above for xopt, and in addition may\n\
7721  contain: v: Write numeric labels for vertical axis parallel to the\n\
7722  base of the graph, rather than parallel to the axis. \n\
7723 \n\
7724 \n\
7725  ytick (PLFLT, input) : World coordinate interval between major\n\
7726  ticks on the y axis. If it is set to zero, PLplot automatically\n\
7727  generates a suitable tick interval. \n\
7728 \n\
7729  nysub (PLINT, input) : Number of subintervals between major y axis\n\
7730  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7731  generates a suitable minor tick interval. \n\
7732 ";
7733 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
7734 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
7735 \n\
7736 DESCRIPTION:\n\
7737 \n\
7738  Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
7739 \n\
7740  Redacted form: plgcolbg(r, g, b)\n\
7741 \n\
7742  This function is used in example 31. \n\
7743 \n\
7744 \n\
7745 \n\
7746 SYNOPSIS:\n\
7747 \n\
7748 plgcolbg(r, g, b)\n\
7749 \n\
7750 ARGUMENTS:\n\
7751 \n\
7752  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7753  representing the degree of red in the color. \n\
7754 \n\
7755  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7756  representing the degree of green in the color. \n\
7757 \n\
7758  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7759  representing the degree of blue in the color. \n\
7760 ";
7761 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
7762 Plot a glyph at the specified 3D points \n\
7763 \n\
7764 DESCRIPTION:\n\
7765 \n\
7766  Plot a glyph at the specified 3D points. (This function is largely\n\
7767  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
7768  Set up the call to this function similar to what is done for plline3.\n\
7769  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7770  and a draw at the same place. Not ideal, since a sufficiently\n\
7771  intelligent output device may optimize it away, or there may be faster\n\
7772  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7773  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7774  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7775  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7776  code <= 127 the corresponding printable ASCII character is plotted. \n\
7777 \n\
7778  Redacted form: plpoin3(x, y, z, code)\n\
7779 \n\
7780  This function is not used in any example. \n\
7781 \n\
7782 \n\
7783 \n\
7784 SYNOPSIS:\n\
7785 \n\
7786 plpoin3(n, x, y, z, code)\n\
7787 \n\
7788 ARGUMENTS:\n\
7789 \n\
7790  n (PLINT, input) : Number of points in the x and y arrays. \n\
7791 \n\
7792  x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7793  points. \n\
7794 \n\
7795  y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7796  points. \n\
7797 \n\
7798  z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7799  points. \n\
7800 \n\
7801  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7802  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7803  each of the n points. \n\
7804 ";
7805 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
7806 Draw a polygon in 3 space \n\
7807 \n\
7808 DESCRIPTION:\n\
7809 \n\
7810  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
7811  like plline3, but differs from that function in that plpoly3 attempts\n\
7812  to determine if the polygon is viewable depending on the order of the\n\
7813  points within the arrays and the value of ifcc. If the back of\n\
7814  polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
7815  you want, then use plline3 instead. \n\
7816 \n\
7817  The points are assumed to be in a plane, and the directionality of the\n\
7818  plane is determined from the first three points. Additional points do\n\
7819  not have to lie on the plane defined by the first three, but if they\n\
7820  do not, then the determination of visibility obviously can\'t be 100%\n\
7821  accurate... So if you\'re 3 space polygons are too far from planar,\n\
7822  consider breaking them into smaller polygons. 3 points define a plane\n\
7823  :-). \n\
7824 \n\
7825  Bugs: If one of the first two segments is of zero length, or if they\n\
7826  are co-linear, the calculation of visibility has a 50/50 chance of\n\
7827  being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
7828  of this problem. (Search for 20.1). \n\
7829 \n\
7830  Redacted form: plpoly3(x, y, z, code)\n\
7831 \n\
7832  This function is used in example 18. \n\
7833 \n\
7834 \n\
7835 \n\
7836 SYNOPSIS:\n\
7837 \n\
7838 plpoly3(n, x, y, z, draw, ifcc)\n\
7839 \n\
7840 ARGUMENTS:\n\
7841 \n\
7842  n (PLINT, input) : Number of points defining line. \n\
7843 \n\
7844  x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
7845 \n\
7846  y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
7847 \n\
7848  z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
7849 \n\
7850  draw (PLBOOL *, input) : Pointer to array which controls drawing\n\
7851  the segments of the polygon. If draw[i] is true, then the polygon\n\
7852  segment from index [i] to [i+1] is drawn, otherwise, not. \n\
7853 \n\
7854  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
7855  polygon is determined by assuming the points are laid out in a\n\
7856  counter-clockwise order. Otherwise, the directionality of the\n\
7857  polygon is determined by assuming the points are laid out in a\n\
7858  clockwise order. \n\
7859 ";
7860 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
7861 Set the background color by 8-bit RGB value and double alpha value. \n\
7862 \n\
7863 DESCRIPTION:\n\
7864 \n\
7865  Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7866  (see the PLplot documentation) and double alpha value. \n\
7867 \n\
7868  This function is used in example 31. \n\
7869 \n\
7870 \n\
7871 \n\
7872 SYNOPSIS:\n\
7873 \n\
7874 plscolbga(r, g, b, a)\n\
7875 \n\
7876 ARGUMENTS:\n\
7877 \n\
7878  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7879  degree of red in the color. \n\
7880 \n\
7881  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7882  degree of green in the color. \n\
7883 \n\
7884  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7885  degree of blue in the color. \n\
7886 \n\
7887  a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
7888  value of the color. \n\
7889 ";
7890 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7891 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n\
7892 \n\
7893 DESCRIPTION:\n\
7894 \n\
7895  Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
7896  alpha value. \n\
7897 \n\
7898  This function is used in example 31. \n\
7899 \n\
7900 \n\
7901 \n\
7902 SYNOPSIS:\n\
7903 \n\
7904 plgcolbga(r, g, b, a)\n\
7905 \n\
7906 ARGUMENTS:\n\
7907 \n\
7908  r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7909  representing the degree of red in the color. \n\
7910 \n\
7911  g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7912  representing the degree of green in the color. \n\
7913 \n\
7914  b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7915  representing the degree of blue in the color. \n\
7916 \n\
7917  a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
7918 ";
7919 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
7920 Draw x error bar \n\
7921 \n\
7922 DESCRIPTION:\n\
7923 \n\
7924  Draws a set of n horizontal error bars, the i\'th error bar extending\n\
7925  from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
7926  error bar are of length equal to the minor tick length (settable using\n\
7927  plsmin). \n\
7928 \n\
7929  Redacted form: General: plerrx(xmin, ymax, y)\n\
7930 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
7931 \n\
7932 \n\
7933  This function is used in example 29. \n\
7934 \n\
7935 \n\
7936 \n\
7937 SYNOPSIS:\n\
7938 \n\
7939 plerrx(n, xmin, xmax, y)\n\
7940 \n\
7941 ARGUMENTS:\n\
7942 \n\
7943  n (PLINT, input) : Number of error bars to draw. \n\
7944 \n\
7945  xmin (PLFLT *, input) : Pointer to array with x coordinates of\n\
7946  left-hand endpoint of error bars. \n\
7947 \n\
7948  xmax (PLFLT *, input) : Pointer to array with x coordinates of\n\
7949  right-hand endpoint of error bars. \n\
7950 \n\
7951  y (PLFLT *, input) : Pointer to array with y coordinates of error\n\
7952  bar. \n\
7953 ";
7954 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
7955 Eject current page \n\
7956 \n\
7957 DESCRIPTION:\n\
7958 \n\
7959  Clears the graphics screen of an interactive device, or ejects a page\n\
7960  on a plotter. See plbop for more information. \n\
7961 \n\
7962  Redacted form: pleop()\n\
7963 \n\
7964  This function is used in example 2,14. \n\
7965 \n\
7966 \n\
7967 \n\
7968 SYNOPSIS:\n\
7969 \n\
7970 pleop()\n\
7971 ";
7972 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
7973 Convert HLS color to RGB \n\
7974 \n\
7975 DESCRIPTION:\n\
7976 \n\
7977  Convert HLS color coordinates to RGB. \n\
7978 \n\
7979  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
7980 \t Perl/PDL: Not available? Implemented as plhls? \n\
7981 \n\
7982 \n\
7983  This function is used in example 2. \n\
7984 \n\
7985 \n\
7986 \n\
7987 SYNOPSIS:\n\
7988 \n\
7989 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
7990 \n\
7991 ARGUMENTS:\n\
7992 \n\
7993  h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
7994 \n\
7995  l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
7996  of the colour cone (0.0-1.0) \n\
7997 \n\
7998  s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
7999  radius of the colour cone (0.0-1.0) \n\
8000 \n\
8001  p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
8002  colour \n\
8003 \n\
8004  p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
8005  colour \n\
8006 \n\
8007  p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
8008  colour \n\
8009 ";
8010 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
8011 Draw y error bar \n\
8012 \n\
8013 DESCRIPTION:\n\
8014 \n\
8015  Draws a set of n vertical error bars, the i\'th error bar extending\n\
8016  from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
8017  error bar are of length equal to the minor tick length (settable using\n\
8018  plsmin). \n\
8019 \n\
8020  Redacted form: General: plerry(x, ymin, ymax)\n\
8021 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
8022 \n\
8023 \n\
8024  This function is used in example 29. \n\
8025 \n\
8026 \n\
8027 \n\
8028 SYNOPSIS:\n\
8029 \n\
8030 plerry(n, x, ymin, ymax)\n\
8031 \n\
8032 ARGUMENTS:\n\
8033 \n\
8034  n (PLINT, input) : Number of error bars to draw. \n\
8035 \n\
8036  x (PLFLT *, input) : Pointer to array with x coordinates of error\n\
8037  bars. \n\
8038 \n\
8039  ymin (PLFLT *, input) : Pointer to array with y coordinates of\n\
8040  lower endpoint of error bars. \n\
8041 \n\
8042  ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n\
8043  endpoint of error bar. \n\
8044 ";
8045 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
8046 Set FCI (font characterization integer) \n\
8047 \n\
8048 DESCRIPTION:\n\
8049 \n\
8050  Sets font characteristics to be used at the start of the next string\n\
8051  using the FCI approach. See the PLplot documentation for more\n\
8052  information. \n\
8053 \n\
8054  Redacted form: General: plsfci(fci)\n\
8055 \t Perl/PDL: Not available? \n\
8056 \n\
8057 \n\
8058  This function is used in example 23. \n\
8059 \n\
8060 \n\
8061 \n\
8062 SYNOPSIS:\n\
8063 \n\
8064 plsfci(fci)\n\
8065 \n\
8066 ARGUMENTS:\n\
8067 \n\
8068  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
8069  of FCI. \n\
8070 ";
8071 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
8072 Select area fill pattern \n\
8073 \n\
8074 DESCRIPTION:\n\
8075 \n\
8076  Select one of eight predefined area fill patterns to use (also see\n\
8077  plpat). Setting the fill style to 0 gives a solid fill. \n\
8078 \n\
8079  Redacted form: plpsty(n)\n\
8080 \n\
8081  This function is used in examples 12,13,15,16,25. \n\
8082 \n\
8083 \n\
8084 \n\
8085 SYNOPSIS:\n\
8086 \n\
8087 plpsty(n)\n\
8088 \n\
8089 ARGUMENTS:\n\
8090 \n\
8091  n (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
8092  horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
8093  consists of lines at 45 degrees angle (upward), and so on. \n\
8094 ";
8095 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
8096 Set symbol size \n\
8097 \n\
8098 DESCRIPTION:\n\
8099 \n\
8100  This sets up the size of all subsequent symbols drawn by plpoin and\n\
8101  plsym. The actual height of a symbol is the product of the default\n\
8102  symbol size and a scaling factor as for the character height. \n\
8103 \n\
8104  Redacted form: plssym(def, scale)\n\
8105 \n\
8106  This function is used in example 29. \n\
8107 \n\
8108 \n\
8109 \n\
8110 SYNOPSIS:\n\
8111 \n\
8112 plssym(def, scale)\n\
8113 \n\
8114 ARGUMENTS:\n\
8115 \n\
8116  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
8117  should be set to zero if the default height is to remain\n\
8118  unchanged. \n\
8119 \n\
8120  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
8121  actual symbol height. \n\
8122 ";
8123 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
8124 Initialization \n\
8125 \n\
8126 DESCRIPTION:\n\
8127 \n\
8128  Alternative to plstar for initializing the plotting package. The\n\
8129  device name keyword for the desired output device must be supplied as\n\
8130  an argument. The device keywords are the same as those printed out by\n\
8131  plstar. If the requested device is not available, or if the input\n\
8132  string is empty or begins with ``?\'\', the prompted startup of plstar\n\
8133  is used. This routine also divides the output device into nx by ny\n\
8134  subpages, each of which may be used independently.\tThe subroutine\n\
8135  pladv is used to advance from one subpage to the next. \n\
8136 \n\
8137  Redacted form: General: plstart(device, nx, ny)\n\
8138 \t Perl/PDL: plstart(nx, ny, device)\n\
8139 \n\
8140 \n\
8141  This function is not used in any examples. \n\
8142 \n\
8143 \n\
8144 \n\
8145 SYNOPSIS:\n\
8146 \n\
8147 plstart(device, nx, ny)\n\
8148 \n\
8149 ARGUMENTS:\n\
8150 \n\
8151  device (const char *, input) : Device name (keyword) of the\n\
8152  required output device. If NULL or if the first character is a\n\
8153  ``?\'\', the normal (prompted) startup is used. \n\
8154 \n\
8155  nx (PLINT, input) : Number of subpages to divide output page in the\n\
8156  horizontal direction. \n\
8157 \n\
8158  ny (PLINT, input) : Number of subpages to divide output page in the\n\
8159  vertical direction. \n\
8160 ";
8161 
8162 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
8163  PLINT arg1 ;
8164  PLINT *arg2 = (PLINT *) 0 ;
8165  char **arg3 = (char **) 0 ;
8166  Matrix temp1 ;
8167  octave_value_list _out;
8168  octave_value_list *_outp=&_out;
8169  octave_value _outv;
8170 
8171  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
8172  SWIG_fail;
8173  }
8174  {
8175  if ( _n_dims( args(0) ) > 1 )
8176  {
8177  error( "argument must be a scalar or vector" ); SWIG_fail;
8178  }
8179  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
8180  arg2 = new PLINT[Alen];
8181  temp1 = args(0).matrix_value();
8182  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
8183  }
8184  {
8185  charMatrix temp_matrix;
8186  Cell temp_cell;
8187  char *tmp_cstring;
8188  std::string str;
8189  size_t max_length, non_blank_length;
8190  int i, ifcell;
8191  if ( _n_dims( args(1) ) > 2 )
8192  {
8193  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
8194  }
8195  if ( !args(1).is_empty() )
8196  {
8197  if ( _dim( args(1), 0 ) != Alen )
8198  {
8199  error( "first dimension must be same length as previous vector" ); SWIG_fail;
8200  }
8201  arg3 = new char*[Alen];
8202  ifcell = args(1).is_cell();
8203  if ( ifcell )
8204  {
8205  temp_cell = args(1).cell_value();
8206  }
8207  else
8208  {
8209  temp_matrix = args(1).char_matrix_value();
8210  // Allow one extra space for null termination.
8211  max_length = _dim( args(1), 1 ) + 1;
8212  }
8213 
8214  for ( i = 0; i < Alen; i++ )
8215  {
8216  // Must copy string to "permanent" location because the string
8217  // location corresponding to tmp_cstring gets
8218  // overwritten for each iteration of loop.
8219  if ( ifcell )
8220  {
8221  if ( temp_cell.elem( i ).is_string() )
8222  {
8223  str = temp_cell.elem( i ).string_value();
8224  // leave room for null termination.
8225  max_length = str.size() + 1;
8226  tmp_cstring = (char *) str.c_str();
8227  }
8228  else
8229  {
8230  // Use null string if user attempts to pass a cell array
8231  // with a non-string element (likely an empty element
8232  // since that should be allowed by the PLplot interface
8233  // if that element is going to be unused).
8234  // leave room for null termination.
8235  max_length = 1;
8236  tmp_cstring = (char *) "";
8237  }
8238  }
8239  else
8240  {
8241  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
8242  }
8243  arg3[i] = new char[max_length];
8244  strncpy( arg3[i], tmp_cstring, max_length - 1 );
8245  arg3[i][max_length - 1] = '\0';
8246  // All the trailing blank crapola should not be needed for
8247  // string cell arrays.
8248  if ( !ifcell )
8249  {
8250  // remove trailing-blank padding that is used by the
8251  // charMatrix class to insure all strings in a given
8252  // charMatrix instance have the same length.
8253  // This transformation also removes legitimate trailing
8254  // blanks but there is nothing we can do about that
8255  // for the charMatrix class.
8256 
8257  // Look for trailing nulls first (just in case, although that
8258  // shouldn't happen if charMatrix implemented as documented)
8259  // before looking for trailing blanks.
8260  non_blank_length = max_length - 2;
8261  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
8262  {
8263  non_blank_length--;
8264  }
8265  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
8266  {
8267  non_blank_length--;
8268  }
8269  arg3[i][non_blank_length + 1] = '\0';
8270  }
8271  }
8272  }
8273  else
8274  {
8275  arg3 = NULL;
8276  }
8277  }
8278  testppchar(arg1,(int const *)arg2,(char const **)arg3);
8279  _outv = octave_value();
8280  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8281  {
8282  delete [] arg2;
8283  }
8284  {
8285  int i;
8286  if ( arg3 != NULL )
8287  {
8288  for ( i = 0; i < Alen; i++ )
8289  {
8290  delete[] arg3[i];
8291  }
8292  delete[] arg3;
8293  }
8294  }
8295  return _out;
8296 fail:
8297  {
8298  delete [] arg2;
8299  }
8300  {
8301  int i;
8302  if ( arg3 != NULL )
8303  {
8304  for ( i = 0; i < Alen; i++ )
8305  {
8306  delete[] arg3[i];
8307  }
8308  delete[] arg3;
8309  }
8310  }
8311  return octave_value_list();
8312 }
8313 
8314 
8316  int *arg1 = (int *) 0 ;
8317  int *arg2 = (int *) 0 ;
8318  int *arg3 = (int *) 0 ;
8319  char *arg4 = (char *) 0 ;
8320  int *arg5 = (int *) 0 ;
8321  int *arg6 = (int *) 0 ;
8322  PLFLT *arg7 = (PLFLT *) 0 ;
8323  PLFLT *arg8 = (PLFLT *) 0 ;
8324  PLFLT *arg9 = (PLFLT *) 0 ;
8325  PLFLT *arg10 = (PLFLT *) 0 ;
8326  int *arg11 = (int *) 0 ;
8327  int temp1 ;
8328  int res1 = SWIG_TMPOBJ ;
8329  int temp2 ;
8330  int res2 = SWIG_TMPOBJ ;
8331  int temp3 ;
8332  int res3 = SWIG_TMPOBJ ;
8333  octave_value_list retval4 ;
8334  int temp5 ;
8335  int res5 = SWIG_TMPOBJ ;
8336  int temp6 ;
8337  int res6 = SWIG_TMPOBJ ;
8338  PLFLT temp7 ;
8339  int res7 = SWIG_TMPOBJ ;
8340  PLFLT temp8 ;
8341  int res8 = SWIG_TMPOBJ ;
8342  PLFLT temp9 ;
8343  int res9 = SWIG_TMPOBJ ;
8344  PLFLT temp10 ;
8345  int res10 = SWIG_TMPOBJ ;
8346  int temp11 ;
8347  int res11 = SWIG_TMPOBJ ;
8348  octave_value_list _out;
8349  octave_value_list *_outp=&_out;
8350  octave_value _outv;
8351  int result;
8352 
8353  arg1 = &temp1;
8354  arg2 = &temp2;
8355  arg3 = &temp3;
8356  {
8357  // Check if version >= 3.4.0
8358 # if OCTAVE_API_VERSION_NUMBER < 45
8359  retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
8360 # else
8361  retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
8362 # endif
8363  arg4 = (char *) retval4( 0 ).char_matrix_value().data();
8364  }
8365  arg5 = &temp5;
8366  arg6 = &temp6;
8367  arg7 = &temp7;
8368  arg8 = &temp8;
8369  arg9 = &temp9;
8370  arg10 = &temp10;
8371  arg11 = &temp11;
8372  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
8373  SWIG_fail;
8374  }
8375  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
8376  _outv = SWIG_From_int((int)(result));
8377  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8378  if (SWIG_IsTmpObj(res1)) {
8379  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8380  } else {
8381  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8382  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8383  }
8384  if (SWIG_IsTmpObj(res2)) {
8385  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
8386  } else {
8387  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8388  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8389  }
8390  if (SWIG_IsTmpObj(res3)) {
8391  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
8392  } else {
8393  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8394  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8395  }
8396  {
8397  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
8398  }
8399  if (SWIG_IsTmpObj(res5)) {
8400  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
8401  } else {
8402  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8403  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
8404  }
8405  if (SWIG_IsTmpObj(res6)) {
8406  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
8407  } else {
8408  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8409  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
8410  }
8411  if (SWIG_IsTmpObj(res7)) {
8412  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
8413  } else {
8414  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8415  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
8416  }
8417  if (SWIG_IsTmpObj(res8)) {
8418  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
8419  } else {
8420  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8421  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
8422  }
8423  if (SWIG_IsTmpObj(res9)) {
8424  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
8425  } else {
8426  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8427  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
8428  }
8429  if (SWIG_IsTmpObj(res10)) {
8430  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
8431  } else {
8432  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8433  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
8434  }
8435  if (SWIG_IsTmpObj(res11)) {
8436  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
8437  } else {
8438  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8439  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
8440  }
8441  return _out;
8442 fail:
8443  return octave_value_list();
8444 }
8445 
8446 
8447 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
8448  PLFLT *arg1 = (PLFLT *) 0 ;
8449  PLFLT *arg2 = (PLFLT *) 0 ;
8450  PLFLT arg3 ;
8451  PLFLT arg4 ;
8452  PLFLT temp1 ;
8453  int res1 = SWIG_TMPOBJ ;
8454  PLFLT temp2 ;
8455  int res2 = SWIG_TMPOBJ ;
8456  double val3 ;
8457  int ecode3 = 0 ;
8458  double val4 ;
8459  int ecode4 = 0 ;
8460  octave_value_list _out;
8461  octave_value_list *_outp=&_out;
8462  octave_value _outv;
8463  int result;
8464 
8465  arg1 = &temp1;
8466  arg2 = &temp2;
8467  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
8468  SWIG_fail;
8469  }
8470  ecode3 = SWIG_AsVal_double(args(0), &val3);
8471  if (!SWIG_IsOK(ecode3)) {
8472  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
8473  }
8474  arg3 = (PLFLT)(val3);
8475  ecode4 = SWIG_AsVal_double(args(1), &val4);
8476  if (!SWIG_IsOK(ecode4)) {
8477  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
8478  }
8479  arg4 = (PLFLT)(val4);
8480  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
8481  _outv = SWIG_From_int((int)(result));
8482  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8483  if (SWIG_IsTmpObj(res1)) {
8484  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
8485  } else {
8486  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8487  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8488  }
8489  if (SWIG_IsTmpObj(res2)) {
8490  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
8491  } else {
8492  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8493  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8494  }
8495  return _out;
8496 fail:
8497  return octave_value_list();
8498 }
8499 
8500 
8501 SWIG_DEFUN( plstripc, _wrap_plstripc, std::string() ) {
8502  PLINT *arg1 = (PLINT *) 0 ;
8503  char *arg2 = (char *) 0 ;
8504  char *arg3 = (char *) 0 ;
8505  PLFLT arg4 ;
8506  PLFLT arg5 ;
8507  PLFLT arg6 ;
8508  PLFLT arg7 ;
8509  PLFLT arg8 ;
8510  PLFLT arg9 ;
8511  PLFLT arg10 ;
8512  PLBOOL arg11 ;
8513  PLBOOL arg12 ;
8514  PLINT arg13 ;
8515  PLINT arg14 ;
8516  PLINT *arg15 = (PLINT *) 0 ;
8517  PLINT *arg16 = (PLINT *) 0 ;
8518  char *arg17 = (char *) 0 ;
8519  char *arg18 = (char *) 0 ;
8520  char *arg19 = (char *) 0 ;
8521  char *arg20 = (char *) 0 ;
8522  char *arg21 = (char *) 0 ;
8523  char *arg22 = (char *) 0 ;
8524  char *arg23 = (char *) 0 ;
8525  PLINT temp1 ;
8526  int res1 = SWIG_TMPOBJ ;
8527  int res2 ;
8528  char *buf2 = 0 ;
8529  int alloc2 = 0 ;
8530  int res3 ;
8531  char *buf3 = 0 ;
8532  int alloc3 = 0 ;
8533  double val4 ;
8534  int ecode4 = 0 ;
8535  double val5 ;
8536  int ecode5 = 0 ;
8537  double val6 ;
8538  int ecode6 = 0 ;
8539  double val7 ;
8540  int ecode7 = 0 ;
8541  double val8 ;
8542  int ecode8 = 0 ;
8543  double val9 ;
8544  int ecode9 = 0 ;
8545  double val10 ;
8546  int ecode10 = 0 ;
8547  int val11 ;
8548  int ecode11 = 0 ;
8549  int val12 ;
8550  int ecode12 = 0 ;
8551  int val13 ;
8552  int ecode13 = 0 ;
8553  int val14 ;
8554  int ecode14 = 0 ;
8555  Matrix temp15 ;
8556  Matrix temp16 ;
8557  int res17 ;
8558  char *buf17 = 0 ;
8559  int alloc17 = 0 ;
8560  int res18 ;
8561  char *buf18 = 0 ;
8562  int alloc18 = 0 ;
8563  int res19 ;
8564  char *buf19 = 0 ;
8565  int alloc19 = 0 ;
8566  int res20 ;
8567  char *buf20 = 0 ;
8568  int alloc20 = 0 ;
8569  int res21 ;
8570  char *buf21 = 0 ;
8571  int alloc21 = 0 ;
8572  int res22 ;
8573  char *buf22 = 0 ;
8574  int alloc22 = 0 ;
8575  int res23 ;
8576  char *buf23 = 0 ;
8577  int alloc23 = 0 ;
8578  octave_value_list _out;
8579  octave_value_list *_outp=&_out;
8580  octave_value _outv;
8581 
8582  arg1 = &temp1;
8583  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
8584  SWIG_fail;
8585  }
8586  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
8587  if (!SWIG_IsOK(res2)) {
8588  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
8589  }
8590  arg2 = (char *)(buf2);
8591  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
8592  if (!SWIG_IsOK(res3)) {
8593  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
8594  }
8595  arg3 = (char *)(buf3);
8596  ecode4 = SWIG_AsVal_double(args(2), &val4);
8597  if (!SWIG_IsOK(ecode4)) {
8598  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
8599  }
8600  arg4 = (PLFLT)(val4);
8601  ecode5 = SWIG_AsVal_double(args(3), &val5);
8602  if (!SWIG_IsOK(ecode5)) {
8603  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
8604  }
8605  arg5 = (PLFLT)(val5);
8606  ecode6 = SWIG_AsVal_double(args(4), &val6);
8607  if (!SWIG_IsOK(ecode6)) {
8608  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
8609  }
8610  arg6 = (PLFLT)(val6);
8611  ecode7 = SWIG_AsVal_double(args(5), &val7);
8612  if (!SWIG_IsOK(ecode7)) {
8613  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
8614  }
8615  arg7 = (PLFLT)(val7);
8616  ecode8 = SWIG_AsVal_double(args(6), &val8);
8617  if (!SWIG_IsOK(ecode8)) {
8618  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
8619  }
8620  arg8 = (PLFLT)(val8);
8621  ecode9 = SWIG_AsVal_double(args(7), &val9);
8622  if (!SWIG_IsOK(ecode9)) {
8623  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
8624  }
8625  arg9 = (PLFLT)(val9);
8626  ecode10 = SWIG_AsVal_double(args(8), &val10);
8627  if (!SWIG_IsOK(ecode10)) {
8628  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
8629  }
8630  arg10 = (PLFLT)(val10);
8631  ecode11 = SWIG_AsVal_int(args(9), &val11);
8632  if (!SWIG_IsOK(ecode11)) {
8633  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
8634  }
8635  arg11 = (PLBOOL)(val11);
8636  ecode12 = SWIG_AsVal_int(args(10), &val12);
8637  if (!SWIG_IsOK(ecode12)) {
8638  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
8639  }
8640  arg12 = (PLBOOL)(val12);
8641  ecode13 = SWIG_AsVal_int(args(11), &val13);
8642  if (!SWIG_IsOK(ecode13)) {
8643  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
8644  }
8645  arg13 = (PLINT)(val13);
8646  ecode14 = SWIG_AsVal_int(args(12), &val14);
8647  if (!SWIG_IsOK(ecode14)) {
8648  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
8649  }
8650  arg14 = (PLINT)(val14);
8651  {
8652  if ( _n_dims( args(13) ) > 1 )
8653  {
8654  error( "argument must be a scalar or vector" ); SWIG_fail;
8655  }
8656  Alen = (PLINT) ( _dim( args(13), 0 ) );
8657  temp15 = args(13).matrix_value();
8658  arg15 = new PLINT[Alen];
8659  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
8660  }
8661  {
8662  if ( _n_dims( args(14) ) > 1 )
8663  {
8664  error( "argument must be a scalar or vector" ); SWIG_fail;
8665  }
8666  if ( _dim( args(14), 0 ) != Alen )
8667  {
8668  error( "argument vectors must be same length" ); SWIG_fail;
8669  }
8670  temp16 = args(14).matrix_value();
8671  arg16 = new PLINT[Alen];
8672  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
8673  }
8674  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
8675  if (!SWIG_IsOK(res17)) {
8676  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
8677  }
8678  arg17 = (char *)(buf17);
8679  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
8680  if (!SWIG_IsOK(res18)) {
8681  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
8682  }
8683  arg18 = (char *)(buf18);
8684  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
8685  if (!SWIG_IsOK(res19)) {
8686  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
8687  }
8688  arg19 = (char *)(buf19);
8689  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
8690  if (!SWIG_IsOK(res20)) {
8691  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
8692  }
8693  arg20 = (char *)(buf20);
8694  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
8695  if (!SWIG_IsOK(res21)) {
8696  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
8697  }
8698  arg21 = (char *)(buf21);
8699  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
8700  if (!SWIG_IsOK(res22)) {
8701  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
8702  }
8703  arg22 = (char *)(buf22);
8704  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
8705  if (!SWIG_IsOK(res23)) {
8706  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
8707  }
8708  arg23 = (char *)(buf23);
8709  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);
8710  _outv = octave_value();
8711  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8712  if (SWIG_IsTmpObj(res1)) {
8713  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8714  } else {
8715  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8716  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8717  }
8718  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8719  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
8720  {
8721  delete [] arg15;
8722  }
8723  {
8724  delete [] arg16;
8725  }
8726  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
8727  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
8728  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
8729  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
8730  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
8731  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
8732  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
8733  return _out;
8734 fail:
8735  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8736  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
8737  {
8738  delete [] arg15;
8739  }
8740  {
8741  delete [] arg16;
8742  }
8743  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
8744  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
8745  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
8746  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
8747  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
8748  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
8749  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
8750  return octave_value_list();
8751 }
8752 
8753 
8754 SWIG_DEFUN( plcont, _wrap_plcont, std::string() ) {
8755  PLFLT *arg1 = (PLFLT *) 0 ;
8756  PLINT arg2 ;
8757  PLINT arg3 ;
8758  PLINT arg4 ;
8759  PLINT arg5 ;
8760  PLINT arg6 ;
8761  PLINT arg7 ;
8762  PLFLT *arg8 = (PLFLT *) 0 ;
8763  PLINT arg9 ;
8764  PLFLT *arg10 = (PLFLT *) 0 ;
8765  Matrix temp1 ;
8766  int val4 ;
8767  int ecode4 = 0 ;
8768  int val5 ;
8769  int ecode5 = 0 ;
8770  int val6 ;
8771  int ecode6 = 0 ;
8772  int val7 ;
8773  int ecode7 = 0 ;
8774  Matrix temp8 ;
8775  Matrix temp10 ;
8776  octave_value_list _out;
8777  octave_value_list *_outp=&_out;
8778  octave_value _outv;
8779 
8780  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
8781  SWIG_fail;
8782  }
8783  {
8784  if ( _n_dims( args(0) ) > 2 )
8785  {
8786  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8787  }
8788  temp1 = args(0).matrix_value();
8789  arg1 = &temp1( 0, 0 );
8790  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8791  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8792  }
8793  ecode4 = SWIG_AsVal_int(args(1), &val4);
8794  if (!SWIG_IsOK(ecode4)) {
8795  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
8796  }
8797  arg4 = (PLINT)(val4);
8798  ecode5 = SWIG_AsVal_int(args(2), &val5);
8799  if (!SWIG_IsOK(ecode5)) {
8800  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
8801  }
8802  arg5 = (PLINT)(val5);
8803  ecode6 = SWIG_AsVal_int(args(3), &val6);
8804  if (!SWIG_IsOK(ecode6)) {
8805  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
8806  }
8807  arg6 = (PLINT)(val6);
8808  ecode7 = SWIG_AsVal_int(args(4), &val7);
8809  if (!SWIG_IsOK(ecode7)) {
8810  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
8811  }
8812  arg7 = (PLINT)(val7);
8813  {
8814  if ( _n_dims( args(5) ) > 1 )
8815  {
8816  error( "argument must be a scalar or vector" ); SWIG_fail;
8817  }
8818  temp8 = args(5).matrix_value();
8819  arg8 = &temp8( 0, 0 );
8820  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8821  }
8822  {
8823  if ( _n_dims( args(6) ) > 1 )
8824  {
8825  error( "argument must be a scalar or vector" ); SWIG_fail;
8826  }
8827  if ( _dim( args(6), 0 ) != 6 )
8828  {
8829  error( "argument vectors must have length of 6" ); SWIG_fail;
8830  }
8831  temp10 = args(6).matrix_value();
8832  arg10 = &temp10( 0, 0 );
8833  }
8834  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
8835  _outv = octave_value();
8836  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8837  {
8838 
8839  }
8840  {
8841 
8842  }
8843  {
8844 
8845  }
8846  return _out;
8847 fail:
8848  {
8849 
8850  }
8851  {
8852 
8853  }
8854  {
8855 
8856  }
8857  return octave_value_list();
8858 }
8859 
8860 
8861 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
8862  PLFLT *arg1 = (PLFLT *) 0 ;
8863  PLINT arg2 ;
8864  PLINT arg3 ;
8865  PLINT arg4 ;
8866  PLINT arg5 ;
8867  PLINT arg6 ;
8868  PLINT arg7 ;
8869  PLFLT *arg8 = (PLFLT *) 0 ;
8870  PLINT arg9 ;
8871  Matrix temp1 ;
8872  int val4 ;
8873  int ecode4 = 0 ;
8874  int val5 ;
8875  int ecode5 = 0 ;
8876  int val6 ;
8877  int ecode6 = 0 ;
8878  int val7 ;
8879  int ecode7 = 0 ;
8880  Matrix temp8 ;
8881  octave_value_list _out;
8882  octave_value_list *_outp=&_out;
8883  octave_value _outv;
8884 
8885  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
8886  SWIG_fail;
8887  }
8888  {
8889  if ( _n_dims( args(0) ) > 2 )
8890  {
8891  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8892  }
8893  temp1 = args(0).matrix_value();
8894  arg1 = &temp1( 0, 0 );
8895  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8896  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8897  }
8898  ecode4 = SWIG_AsVal_int(args(1), &val4);
8899  if (!SWIG_IsOK(ecode4)) {
8900  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
8901  }
8902  arg4 = (PLINT)(val4);
8903  ecode5 = SWIG_AsVal_int(args(2), &val5);
8904  if (!SWIG_IsOK(ecode5)) {
8905  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
8906  }
8907  arg5 = (PLINT)(val5);
8908  ecode6 = SWIG_AsVal_int(args(3), &val6);
8909  if (!SWIG_IsOK(ecode6)) {
8910  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
8911  }
8912  arg6 = (PLINT)(val6);
8913  ecode7 = SWIG_AsVal_int(args(4), &val7);
8914  if (!SWIG_IsOK(ecode7)) {
8915  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
8916  }
8917  arg7 = (PLINT)(val7);
8918  {
8919  if ( _n_dims( args(5) ) > 1 )
8920  {
8921  error( "argument must be a scalar or vector" ); SWIG_fail;
8922  }
8923  temp8 = args(5).matrix_value();
8924  arg8 = &temp8( 0, 0 );
8925  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8926  }
8927  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
8928  _outv = octave_value();
8929  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8930  {
8931 
8932  }
8933  {
8934 
8935  }
8936  return _out;
8937 fail:
8938  {
8939 
8940  }
8941  {
8942 
8943  }
8944  return octave_value_list();
8945 }
8946 
8947 
8948 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
8949  PLFLT *arg1 = (PLFLT *) 0 ;
8950  PLINT arg2 ;
8951  PLINT arg3 ;
8952  PLINT arg4 ;
8953  PLINT arg5 ;
8954  PLINT arg6 ;
8955  PLINT arg7 ;
8956  PLFLT *arg8 = (PLFLT *) 0 ;
8957  PLINT arg9 ;
8958  PLFLT *arg10 = (PLFLT *) 0 ;
8959  PLFLT *arg11 = (PLFLT *) 0 ;
8960  Matrix temp1 ;
8961  int val4 ;
8962  int ecode4 = 0 ;
8963  int val5 ;
8964  int ecode5 = 0 ;
8965  int val6 ;
8966  int ecode6 = 0 ;
8967  int val7 ;
8968  int ecode7 = 0 ;
8969  Matrix temp8 ;
8970  Matrix temp10 ;
8971  Matrix temp11 ;
8972  octave_value_list _out;
8973  octave_value_list *_outp=&_out;
8974  octave_value _outv;
8975 
8976  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
8977  SWIG_fail;
8978  }
8979  {
8980  if ( _n_dims( args(0) ) > 2 )
8981  {
8982  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8983  }
8984  temp1 = args(0).matrix_value();
8985  arg1 = &temp1( 0, 0 );
8986  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8987  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8988  }
8989  ecode4 = SWIG_AsVal_int(args(1), &val4);
8990  if (!SWIG_IsOK(ecode4)) {
8991  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
8992  }
8993  arg4 = (PLINT)(val4);
8994  ecode5 = SWIG_AsVal_int(args(2), &val5);
8995  if (!SWIG_IsOK(ecode5)) {
8996  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
8997  }
8998  arg5 = (PLINT)(val5);
8999  ecode6 = SWIG_AsVal_int(args(3), &val6);
9000  if (!SWIG_IsOK(ecode6)) {
9001  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
9002  }
9003  arg6 = (PLINT)(val6);
9004  ecode7 = SWIG_AsVal_int(args(4), &val7);
9005  if (!SWIG_IsOK(ecode7)) {
9006  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
9007  }
9008  arg7 = (PLINT)(val7);
9009  {
9010  if ( _n_dims( args(5) ) > 1 )
9011  {
9012  error( "argument must be a scalar or vector" ); SWIG_fail;
9013  }
9014  temp8 = args(5).matrix_value();
9015  arg8 = &temp8( 0, 0 );
9016  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9017  }
9018  {
9019  if ( _n_dims( args(6) ) > 1 )
9020  {
9021  error( "argument must be a scalar or vector" ); SWIG_fail;
9022  }
9023  if ( _dim( args(6), 0 ) != Xlen )
9024  {
9025  error( "argument vectors must be same length" ); SWIG_fail;
9026  }
9027  temp10 = args(6).matrix_value();
9028  arg10 = &temp10( 0, 0 );
9029  }
9030  {
9031  if ( _n_dims( args(7) ) > 1 )
9032  {
9033  error( "argument must be a scalar or vector" ); SWIG_fail;
9034  }
9035  if ( _dim( args(7), 0 ) != Ylen )
9036  {
9037  error( "argument vectors must be same length" ); SWIG_fail;
9038  }
9039  temp11 = args(7).matrix_value();
9040  arg11 = &temp11( 0, 0 );
9041  }
9042  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9043  _outv = octave_value();
9044  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9045  {
9046 
9047  }
9048  {
9049 
9050  }
9051  {
9052 
9053  }
9054  {
9055 
9056  }
9057  return _out;
9058 fail:
9059  {
9060 
9061  }
9062  {
9063 
9064  }
9065  {
9066 
9067  }
9068  {
9069 
9070  }
9071  return octave_value_list();
9072 }
9073 
9074 
9075 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
9076  PLFLT *arg1 = (PLFLT *) 0 ;
9077  PLINT arg2 ;
9078  PLINT arg3 ;
9079  PLINT arg4 ;
9080  PLINT arg5 ;
9081  PLINT arg6 ;
9082  PLINT arg7 ;
9083  PLFLT *arg8 = (PLFLT *) 0 ;
9084  PLINT arg9 ;
9085  PLFLT *arg10 = (PLFLT *) 0 ;
9086  PLFLT *arg11 = (PLFLT *) 0 ;
9087  Matrix temp1 ;
9088  int val4 ;
9089  int ecode4 = 0 ;
9090  int val5 ;
9091  int ecode5 = 0 ;
9092  int val6 ;
9093  int ecode6 = 0 ;
9094  int val7 ;
9095  int ecode7 = 0 ;
9096  Matrix temp8 ;
9097  Matrix temp10 ;
9098  Matrix temp11 ;
9099  octave_value_list _out;
9100  octave_value_list *_outp=&_out;
9101  octave_value _outv;
9102 
9103  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
9104  SWIG_fail;
9105  }
9106  {
9107  if ( _n_dims( args(0) ) > 2 )
9108  {
9109  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9110  }
9111  temp1 = args(0).matrix_value();
9112  arg1 = &temp1( 0, 0 );
9113  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9114  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9115  }
9116  ecode4 = SWIG_AsVal_int(args(1), &val4);
9117  if (!SWIG_IsOK(ecode4)) {
9118  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
9119  }
9120  arg4 = (PLINT)(val4);
9121  ecode5 = SWIG_AsVal_int(args(2), &val5);
9122  if (!SWIG_IsOK(ecode5)) {
9123  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
9124  }
9125  arg5 = (PLINT)(val5);
9126  ecode6 = SWIG_AsVal_int(args(3), &val6);
9127  if (!SWIG_IsOK(ecode6)) {
9128  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
9129  }
9130  arg6 = (PLINT)(val6);
9131  ecode7 = SWIG_AsVal_int(args(4), &val7);
9132  if (!SWIG_IsOK(ecode7)) {
9133  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
9134  }
9135  arg7 = (PLINT)(val7);
9136  {
9137  if ( _n_dims( args(5) ) > 1 )
9138  {
9139  error( "argument must be a scalar or vector" ); SWIG_fail;
9140  }
9141  temp8 = args(5).matrix_value();
9142  arg8 = &temp8( 0, 0 );
9143  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9144  }
9145  {
9146  if ( _n_dims( args(6) ) > 2 )
9147  {
9148  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9149  }
9150  if ( _dim( args(6), 0 ) != Xlen )
9151  {
9152  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9153  }
9154  if ( _dim( args(6), 1 ) != Ylen )
9155  {
9156  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9157  }
9158  temp10 = args(6).matrix_value();
9159  arg10 = &temp10( 0, 0 );
9160  }
9161  {
9162  if ( _n_dims( args(7) ) > 2 )
9163  {
9164  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9165  }
9166  if ( _dim( args(7), 0 ) != Xlen )
9167  {
9168  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9169  }
9170  if ( _dim( args(7), 1 ) != Ylen )
9171  {
9172  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9173  }
9174  temp11 = args(7).matrix_value();
9175  arg11 = &temp11( 0, 0 );
9176  }
9177  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9178  _outv = octave_value();
9179  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9180  {
9181 
9182  }
9183  {
9184 
9185  }
9186  {
9187 
9188  }
9189  {
9190 
9191  }
9192  return _out;
9193 fail:
9194  {
9195 
9196  }
9197  {
9198 
9199  }
9200  {
9201 
9202  }
9203  {
9204 
9205  }
9206  return octave_value_list();
9207 }
9208 
9209 
9210 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
9211  PLFLT *arg1 = (PLFLT *) 0 ;
9212  PLINT arg2 ;
9213  PLINT arg3 ;
9214  PLINT arg4 ;
9215  PLINT arg5 ;
9216  PLINT arg6 ;
9217  PLINT arg7 ;
9218  PLFLT *arg8 = (PLFLT *) 0 ;
9219  PLINT arg9 ;
9220  PLFLT *arg10 = (PLFLT *) 0 ;
9221  PLFLT *arg11 = (PLFLT *) 0 ;
9222  Matrix temp1 ;
9223  int val4 ;
9224  int ecode4 = 0 ;
9225  int val5 ;
9226  int ecode5 = 0 ;
9227  int val6 ;
9228  int ecode6 = 0 ;
9229  int val7 ;
9230  int ecode7 = 0 ;
9231  Matrix temp8 ;
9232  Matrix temp10 ;
9233  Matrix temp11 ;
9234  octave_value_list _out;
9235  octave_value_list *_outp=&_out;
9236  octave_value _outv;
9237 
9238  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
9239  SWIG_fail;
9240  }
9241  {
9242  if ( _n_dims( args(0) ) > 2 )
9243  {
9244  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9245  }
9246  temp1 = args(0).matrix_value();
9247  arg1 = &temp1( 0, 0 );
9248  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9249  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9250  }
9251  ecode4 = SWIG_AsVal_int(args(1), &val4);
9252  if (!SWIG_IsOK(ecode4)) {
9253  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
9254  }
9255  arg4 = (PLINT)(val4);
9256  ecode5 = SWIG_AsVal_int(args(2), &val5);
9257  if (!SWIG_IsOK(ecode5)) {
9258  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
9259  }
9260  arg5 = (PLINT)(val5);
9261  ecode6 = SWIG_AsVal_int(args(3), &val6);
9262  if (!SWIG_IsOK(ecode6)) {
9263  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
9264  }
9265  arg6 = (PLINT)(val6);
9266  ecode7 = SWIG_AsVal_int(args(4), &val7);
9267  if (!SWIG_IsOK(ecode7)) {
9268  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
9269  }
9270  arg7 = (PLINT)(val7);
9271  {
9272  if ( _n_dims( args(5) ) > 1 )
9273  {
9274  error( "argument must be a scalar or vector" ); SWIG_fail;
9275  }
9276  temp8 = args(5).matrix_value();
9277  arg8 = &temp8( 0, 0 );
9278  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9279  }
9280  {
9281  if ( _n_dims( args(6) ) > 2 )
9282  {
9283  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9284  }
9285  if ( _dim( args(6), 0 ) != Xlen )
9286  {
9287  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9288  }
9289  if ( _dim( args(6), 1 ) != Ylen )
9290  {
9291  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9292  }
9293  temp10 = args(6).matrix_value();
9294  arg10 = &temp10( 0, 0 );
9295  }
9296  {
9297  if ( _n_dims( args(7) ) > 2 )
9298  {
9299  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9300  }
9301  if ( _dim( args(7), 0 ) != Xlen )
9302  {
9303  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9304  }
9305  if ( _dim( args(7), 1 ) != Ylen )
9306  {
9307  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9308  }
9309  temp11 = args(7).matrix_value();
9310  arg11 = &temp11( 0, 0 );
9311  }
9312  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9313  _outv = octave_value();
9314  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9315  {
9316 
9317  }
9318  {
9319 
9320  }
9321  {
9322 
9323  }
9324  {
9325 
9326  }
9327  return _out;
9328 fail:
9329  {
9330 
9331  }
9332  {
9333 
9334  }
9335  {
9336 
9337  }
9338  {
9339 
9340  }
9341  return octave_value_list();
9342 }
9343 
9344 
9346  PLFLT *arg1 = (PLFLT *) 0 ;
9347  PLFLT *arg2 = (PLFLT *) 0 ;
9348  PLFLT *arg3 = (PLFLT *) 0 ;
9349  PLINT arg4 ;
9350  PLFLT *arg5 = (PLFLT *) 0 ;
9351  PLINT arg6 ;
9352  PLFLT *arg7 = (PLFLT *) 0 ;
9353  PLINT arg8 ;
9354  PLFLT *arg9 = (PLFLT *) 0 ;
9355  PLINT arg10 ;
9356  PLFLT arg11 ;
9357  Matrix temp1 ;
9358  Matrix temp2 ;
9359  Matrix temp3 ;
9360  Matrix temp5 ;
9361  Matrix temp7 ;
9362  octave_value_list retval7 ;
9363  int val10 ;
9364  int ecode10 = 0 ;
9365  double val11 ;
9366  int ecode11 = 0 ;
9367  octave_value_list _out;
9368  octave_value_list *_outp=&_out;
9369  octave_value _outv;
9370 
9371  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
9372  SWIG_fail;
9373  }
9374  {
9375  if ( _n_dims( args(0) ) > 1 )
9376  {
9377  error( "argument must be a scalar or vector" ); SWIG_fail;
9378  }
9379  Alen = (PLINT) ( _dim( args(0), 0 ) );
9380  temp1 = args(0).matrix_value();
9381  arg1 = &temp1( 0, 0 );
9382  }
9383  {
9384  if ( _n_dims( args(1) ) > 1 )
9385  {
9386  error( "argument must be a scalar or vector" ); SWIG_fail;
9387  }
9388  if ( _dim( args(1), 0 ) != Alen )
9389  {
9390  error( "argument vectors must be same length" ); SWIG_fail;
9391  }
9392  temp2 = args(1).matrix_value();
9393  arg2 = &temp2( 0, 0 );
9394  }
9395  {
9396  if ( _n_dims( args(2) ) > 1 )
9397  {
9398  error( "argument must be a scalar or vector" ); SWIG_fail;
9399  }
9400  if ( _dim( args(2), 0 ) != Alen )
9401  {
9402  error( "argument vectors must be same length" ); SWIG_fail;
9403  }
9404  temp3 = args(2).matrix_value();
9405  arg3 = &temp3( 0, 0 );
9406  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9407  }
9408  {
9409  if ( _n_dims( args(3) ) > 1 )
9410  {
9411  error( "argument must be a scalar or vector" ); SWIG_fail;
9412  }
9413  temp5 = args(3).matrix_value();
9414  arg5 = &temp5( 0, 0 );
9415  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
9416  }
9417  {
9418  if ( _n_dims( args(4) ) > 1 )
9419  {
9420  error( "argument must be a scalar or vector" ); SWIG_fail;
9421  }
9422  temp7 = args(4).matrix_value();
9423  arg7 = &temp7( 0, 0 );
9424  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
9425  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
9426  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
9427  }
9428  ecode10 = SWIG_AsVal_int(args(5), &val10);
9429  if (!SWIG_IsOK(ecode10)) {
9430  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
9431  }
9432  arg10 = (PLINT)(val10);
9433  ecode11 = SWIG_AsVal_double(args(6), &val11);
9434  if (!SWIG_IsOK(ecode11)) {
9435  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
9436  }
9437  arg11 = (PLFLT)(val11);
9438  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
9439  _outv = octave_value();
9440  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9441  {
9442  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
9443  }
9444  {
9445 
9446  }
9447  {
9448 
9449  }
9450  {
9451 
9452  }
9453  {
9454 
9455  }
9456  {
9457 
9458  }
9459  return _out;
9460 fail:
9461  {
9462 
9463  }
9464  {
9465 
9466  }
9467  {
9468 
9469  }
9470  {
9471 
9472  }
9473  {
9474 
9475  }
9476  return octave_value_list();
9477 }
9478 
9479 
9480 SWIG_DEFUN( plmesh, _wrap_plmesh, std::string() ) {
9481  PLFLT *arg1 = (PLFLT *) 0 ;
9482  PLFLT *arg2 = (PLFLT *) 0 ;
9483  PLFLT *arg3 = (PLFLT *) 0 ;
9484  PLINT arg4 ;
9485  PLINT arg5 ;
9486  PLINT arg6 ;
9487  Matrix temp1 ;
9488  Matrix temp2 ;
9489  Matrix temp3 ;
9490  int val6 ;
9491  int ecode6 = 0 ;
9492  octave_value_list _out;
9493  octave_value_list *_outp=&_out;
9494  octave_value _outv;
9495 
9496  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
9497  SWIG_fail;
9498  }
9499  {
9500  if ( _n_dims( args(0) ) > 1 )
9501  {
9502  error( "argument must be a scalar or vector" ); SWIG_fail;
9503  }
9504  temp1 = args(0).matrix_value();
9505  arg1 = &temp1( 0, 0 );
9506  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9507  }
9508  {
9509  if ( _n_dims( args(1) ) > 1 )
9510  {
9511  error( "argument must be a scalar or vector" ); SWIG_fail;
9512  }
9513  temp2 = args(1).matrix_value();
9514  arg2 = &temp2( 0, 0 );
9515  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9516  }
9517  {
9518  if ( _n_dims( args(2) ) > 2 )
9519  {
9520  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9521  }
9522  if ( _dim( args(2), 0 ) != Xlen )
9523  {
9524  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9525  }
9526  if ( _dim( args(2), 1 ) != Ylen )
9527  {
9528  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9529  }
9530  temp3 = args(2).matrix_value();
9531  arg3 = &temp3( 0, 0 );
9532  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9533  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9534  }
9535  ecode6 = SWIG_AsVal_int(args(3), &val6);
9536  if (!SWIG_IsOK(ecode6)) {
9537  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9538  }
9539  arg6 = (PLINT)(val6);
9540  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
9541  _outv = octave_value();
9542  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9543  {
9544 
9545  }
9546  {
9547 
9548  }
9549  {
9550 
9551  }
9552  return _out;
9553 fail:
9554  {
9555 
9556  }
9557  {
9558 
9559  }
9560  {
9561 
9562  }
9563  return octave_value_list();
9564 }
9565 
9566 
9567 SWIG_DEFUN( plmeshc, _wrap_plmeshc, std::string() ) {
9568  PLFLT *arg1 = (PLFLT *) 0 ;
9569  PLFLT *arg2 = (PLFLT *) 0 ;
9570  PLFLT *arg3 = (PLFLT *) 0 ;
9571  PLINT arg4 ;
9572  PLINT arg5 ;
9573  PLINT arg6 ;
9574  PLFLT *arg7 = (PLFLT *) 0 ;
9575  PLINT arg8 ;
9576  Matrix temp1 ;
9577  Matrix temp2 ;
9578  Matrix temp3 ;
9579  int val6 ;
9580  int ecode6 = 0 ;
9581  Matrix temp7 ;
9582  octave_value_list _out;
9583  octave_value_list *_outp=&_out;
9584  octave_value _outv;
9585 
9586  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
9587  SWIG_fail;
9588  }
9589  {
9590  if ( _n_dims( args(0) ) > 1 )
9591  {
9592  error( "argument must be a scalar or vector" ); SWIG_fail;
9593  }
9594  temp1 = args(0).matrix_value();
9595  arg1 = &temp1( 0, 0 );
9596  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9597  }
9598  {
9599  if ( _n_dims( args(1) ) > 1 )
9600  {
9601  error( "argument must be a scalar or vector" ); SWIG_fail;
9602  }
9603  temp2 = args(1).matrix_value();
9604  arg2 = &temp2( 0, 0 );
9605  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9606  }
9607  {
9608  if ( _n_dims( args(2) ) > 2 )
9609  {
9610  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9611  }
9612  if ( _dim( args(2), 0 ) != Xlen )
9613  {
9614  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9615  }
9616  if ( _dim( args(2), 1 ) != Ylen )
9617  {
9618  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9619  }
9620  temp3 = args(2).matrix_value();
9621  arg3 = &temp3( 0, 0 );
9622  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9623  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9624  }
9625  ecode6 = SWIG_AsVal_int(args(3), &val6);
9626  if (!SWIG_IsOK(ecode6)) {
9627  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9628  }
9629  arg6 = (PLINT)(val6);
9630  {
9631  if ( _n_dims( args(4) ) > 1 )
9632  {
9633  error( "argument must be a scalar or vector" ); SWIG_fail;
9634  }
9635  temp7 = args(4).matrix_value();
9636  arg7 = &temp7( 0, 0 );
9637  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9638  }
9639  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9640  _outv = octave_value();
9641  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9642  {
9643 
9644  }
9645  {
9646 
9647  }
9648  {
9649 
9650  }
9651  {
9652 
9653  }
9654  return _out;
9655 fail:
9656  {
9657 
9658  }
9659  {
9660 
9661  }
9662  {
9663 
9664  }
9665  {
9666 
9667  }
9668  return octave_value_list();
9669 }
9670 
9671 
9672 SWIG_DEFUN( plot3d, _wrap_plot3d, std::string() ) {
9673  PLFLT *arg1 = (PLFLT *) 0 ;
9674  PLFLT *arg2 = (PLFLT *) 0 ;
9675  PLFLT *arg3 = (PLFLT *) 0 ;
9676  PLINT arg4 ;
9677  PLINT arg5 ;
9678  PLINT arg6 ;
9679  PLBOOL arg7 ;
9680  Matrix temp1 ;
9681  Matrix temp2 ;
9682  Matrix temp3 ;
9683  int val6 ;
9684  int ecode6 = 0 ;
9685  int val7 ;
9686  int ecode7 = 0 ;
9687  octave_value_list _out;
9688  octave_value_list *_outp=&_out;
9689  octave_value _outv;
9690 
9691  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
9692  SWIG_fail;
9693  }
9694  {
9695  if ( _n_dims( args(0) ) > 1 )
9696  {
9697  error( "argument must be a scalar or vector" ); SWIG_fail;
9698  }
9699  temp1 = args(0).matrix_value();
9700  arg1 = &temp1( 0, 0 );
9701  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9702  }
9703  {
9704  if ( _n_dims( args(1) ) > 1 )
9705  {
9706  error( "argument must be a scalar or vector" ); SWIG_fail;
9707  }
9708  temp2 = args(1).matrix_value();
9709  arg2 = &temp2( 0, 0 );
9710  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9711  }
9712  {
9713  if ( _n_dims( args(2) ) > 2 )
9714  {
9715  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9716  }
9717  if ( _dim( args(2), 0 ) != Xlen )
9718  {
9719  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9720  }
9721  if ( _dim( args(2), 1 ) != Ylen )
9722  {
9723  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9724  }
9725  temp3 = args(2).matrix_value();
9726  arg3 = &temp3( 0, 0 );
9727  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9728  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9729  }
9730  ecode6 = SWIG_AsVal_int(args(3), &val6);
9731  if (!SWIG_IsOK(ecode6)) {
9732  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9733  }
9734  arg6 = (PLINT)(val6);
9735  ecode7 = SWIG_AsVal_int(args(4), &val7);
9736  if (!SWIG_IsOK(ecode7)) {
9737  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9738  }
9739  arg7 = (PLBOOL)(val7);
9740  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
9741  _outv = octave_value();
9742  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9743  {
9744 
9745  }
9746  {
9747 
9748  }
9749  {
9750 
9751  }
9752  return _out;
9753 fail:
9754  {
9755 
9756  }
9757  {
9758 
9759  }
9760  {
9761 
9762  }
9763  return octave_value_list();
9764 }
9765 
9766 
9767 SWIG_DEFUN( plot3dc, _wrap_plot3dc, std::string() ) {
9768  PLFLT *arg1 = (PLFLT *) 0 ;
9769  PLFLT *arg2 = (PLFLT *) 0 ;
9770  PLFLT *arg3 = (PLFLT *) 0 ;
9771  PLINT arg4 ;
9772  PLINT arg5 ;
9773  PLINT arg6 ;
9774  PLFLT *arg7 = (PLFLT *) 0 ;
9775  PLINT arg8 ;
9776  Matrix temp1 ;
9777  Matrix temp2 ;
9778  Matrix temp3 ;
9779  int val6 ;
9780  int ecode6 = 0 ;
9781  Matrix temp7 ;
9782  octave_value_list _out;
9783  octave_value_list *_outp=&_out;
9784  octave_value _outv;
9785 
9786  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
9787  SWIG_fail;
9788  }
9789  {
9790  if ( _n_dims( args(0) ) > 1 )
9791  {
9792  error( "argument must be a scalar or vector" ); SWIG_fail;
9793  }
9794  temp1 = args(0).matrix_value();
9795  arg1 = &temp1( 0, 0 );
9796  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9797  }
9798  {
9799  if ( _n_dims( args(1) ) > 1 )
9800  {
9801  error( "argument must be a scalar or vector" ); SWIG_fail;
9802  }
9803  temp2 = args(1).matrix_value();
9804  arg2 = &temp2( 0, 0 );
9805  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9806  }
9807  {
9808  if ( _n_dims( args(2) ) > 2 )
9809  {
9810  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9811  }
9812  if ( _dim( args(2), 0 ) != Xlen )
9813  {
9814  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9815  }
9816  if ( _dim( args(2), 1 ) != Ylen )
9817  {
9818  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9819  }
9820  temp3 = args(2).matrix_value();
9821  arg3 = &temp3( 0, 0 );
9822  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9823  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9824  }
9825  ecode6 = SWIG_AsVal_int(args(3), &val6);
9826  if (!SWIG_IsOK(ecode6)) {
9827  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9828  }
9829  arg6 = (PLINT)(val6);
9830  {
9831  if ( _n_dims( args(4) ) > 1 )
9832  {
9833  error( "argument must be a scalar or vector" ); SWIG_fail;
9834  }
9835  temp7 = args(4).matrix_value();
9836  arg7 = &temp7( 0, 0 );
9837  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9838  }
9839  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9840  _outv = octave_value();
9841  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9842  {
9843 
9844  }
9845  {
9846 
9847  }
9848  {
9849 
9850  }
9851  {
9852 
9853  }
9854  return _out;
9855 fail:
9856  {
9857 
9858  }
9859  {
9860 
9861  }
9862  {
9863 
9864  }
9865  {
9866 
9867  }
9868  return octave_value_list();
9869 }
9870 
9871 
9872 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, std::string() ) {
9873  PLFLT *arg1 = (PLFLT *) 0 ;
9874  PLFLT *arg2 = (PLFLT *) 0 ;
9875  PLFLT *arg3 = (PLFLT *) 0 ;
9876  PLINT arg4 ;
9877  PLINT arg5 ;
9878  PLINT arg6 ;
9879  PLFLT *arg7 = (PLFLT *) 0 ;
9880  PLINT arg8 ;
9881  Matrix temp1 ;
9882  Matrix temp2 ;
9883  Matrix temp3 ;
9884  int val6 ;
9885  int ecode6 = 0 ;
9886  Matrix temp7 ;
9887  octave_value_list _out;
9888  octave_value_list *_outp=&_out;
9889  octave_value _outv;
9890 
9891  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
9892  SWIG_fail;
9893  }
9894  {
9895  if ( _n_dims( args(0) ) > 1 )
9896  {
9897  error( "argument must be a scalar or vector" ); SWIG_fail;
9898  }
9899  temp1 = args(0).matrix_value();
9900  arg1 = &temp1( 0, 0 );
9901  Xlen = (PLINT) ( _dim( args(0), 0 ) );
9902  }
9903  {
9904  if ( _n_dims( args(1) ) > 1 )
9905  {
9906  error( "argument must be a scalar or vector" ); SWIG_fail;
9907  }
9908  temp2 = args(1).matrix_value();
9909  arg2 = &temp2( 0, 0 );
9910  Ylen = (PLINT) ( _dim( args(1), 0 ) );
9911  }
9912  {
9913  if ( _n_dims( args(2) ) > 2 )
9914  {
9915  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9916  }
9917  if ( _dim( args(2), 0 ) != Xlen )
9918  {
9919  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9920  }
9921  if ( _dim( args(2), 1 ) != Ylen )
9922  {
9923  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9924  }
9925  temp3 = args(2).matrix_value();
9926  arg3 = &temp3( 0, 0 );
9927  arg4 = (PLINT) ( _dim( args(2), 0 ) );
9928  arg5 = (PLINT) ( _dim( args(2), 1 ) );
9929  }
9930  ecode6 = SWIG_AsVal_int(args(3), &val6);
9931  if (!SWIG_IsOK(ecode6)) {
9932  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9933  }
9934  arg6 = (PLINT)(val6);
9935  {
9936  if ( _n_dims( args(4) ) > 1 )
9937  {
9938  error( "argument must be a scalar or vector" ); SWIG_fail;
9939  }
9940  temp7 = args(4).matrix_value();
9941  arg7 = &temp7( 0, 0 );
9942  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9943  }
9944  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9945  _outv = octave_value();
9946  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9947  {
9948 
9949  }
9950  {
9951 
9952  }
9953  {
9954 
9955  }
9956  {
9957 
9958  }
9959  return _out;
9960 fail:
9961  {
9962 
9963  }
9964  {
9965 
9966  }
9967  {
9968 
9969  }
9970  {
9971 
9972  }
9973  return octave_value_list();
9974 }
9975 
9976 
9977 SWIG_DEFUN( plshade, _wrap_plshade, std::string() ) {
9978  PLFLT *arg1 = (PLFLT *) 0 ;
9979  PLINT arg2 ;
9980  PLINT arg3 ;
9981  PLFLT *arg4 = (PLFLT *) 0 ;
9982  PLFLT arg5 ;
9983  PLFLT arg6 ;
9984  PLFLT arg7 ;
9985  PLFLT arg8 ;
9986  PLFLT arg9 ;
9987  PLFLT arg10 ;
9988  PLINT arg11 ;
9989  PLFLT arg12 ;
9990  PLINT arg13 ;
9991  PLINT arg14 ;
9992  PLINT arg15 ;
9993  PLINT arg16 ;
9994  PLINT arg17 ;
9995  PLBOOL arg18 ;
9996  PLFLT *arg19 = (PLFLT *) 0 ;
9997  Matrix temp1 ;
9998  Matrix temp4 ;
9999  double val5 ;
10000  int ecode5 = 0 ;
10001  double val6 ;
10002  int ecode6 = 0 ;
10003  double val7 ;
10004  int ecode7 = 0 ;
10005  double val8 ;
10006  int ecode8 = 0 ;
10007  double val9 ;
10008  int ecode9 = 0 ;
10009  double val10 ;
10010  int ecode10 = 0 ;
10011  int val11 ;
10012  int ecode11 = 0 ;
10013  double val12 ;
10014  int ecode12 = 0 ;
10015  int val13 ;
10016  int ecode13 = 0 ;
10017  int val14 ;
10018  int ecode14 = 0 ;
10019  int val15 ;
10020  int ecode15 = 0 ;
10021  int val16 ;
10022  int ecode16 = 0 ;
10023  int val17 ;
10024  int ecode17 = 0 ;
10025  int val18 ;
10026  int ecode18 = 0 ;
10027  Matrix temp19 ;
10028  octave_value_list _out;
10029  octave_value_list *_outp=&_out;
10030  octave_value _outv;
10031 
10032  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
10033  SWIG_fail;
10034  }
10035  {
10036  if ( _n_dims( args(0) ) > 2 )
10037  {
10038  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10039  }
10040  temp1 = args(0).matrix_value();
10041  arg1 = &temp1( 0, 0 );
10042  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10043  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10044  }
10045  {
10046  if ( _n_dims( args(1) ) > 1 )
10047  {
10048  error( "argument must be a scalar or vector" ); SWIG_fail;
10049  }
10050  Alen = (PLINT) ( _dim( args(1), 0 ) );
10051  temp4 = args(1).matrix_value();
10052  arg4 = &temp4( 0, 0 );
10053  }
10054  ecode5 = SWIG_AsVal_double(args(2), &val5);
10055  if (!SWIG_IsOK(ecode5)) {
10056  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
10057  }
10058  arg5 = (PLFLT)(val5);
10059  ecode6 = SWIG_AsVal_double(args(3), &val6);
10060  if (!SWIG_IsOK(ecode6)) {
10061  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
10062  }
10063  arg6 = (PLFLT)(val6);
10064  ecode7 = SWIG_AsVal_double(args(4), &val7);
10065  if (!SWIG_IsOK(ecode7)) {
10066  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
10067  }
10068  arg7 = (PLFLT)(val7);
10069  ecode8 = SWIG_AsVal_double(args(5), &val8);
10070  if (!SWIG_IsOK(ecode8)) {
10071  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
10072  }
10073  arg8 = (PLFLT)(val8);
10074  ecode9 = SWIG_AsVal_double(args(6), &val9);
10075  if (!SWIG_IsOK(ecode9)) {
10076  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
10077  }
10078  arg9 = (PLFLT)(val9);
10079  ecode10 = SWIG_AsVal_double(args(7), &val10);
10080  if (!SWIG_IsOK(ecode10)) {
10081  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
10082  }
10083  arg10 = (PLFLT)(val10);
10084  ecode11 = SWIG_AsVal_int(args(8), &val11);
10085  if (!SWIG_IsOK(ecode11)) {
10086  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
10087  }
10088  arg11 = (PLINT)(val11);
10089  ecode12 = SWIG_AsVal_double(args(9), &val12);
10090  if (!SWIG_IsOK(ecode12)) {
10091  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
10092  }
10093  arg12 = (PLFLT)(val12);
10094  ecode13 = SWIG_AsVal_int(args(10), &val13);
10095  if (!SWIG_IsOK(ecode13)) {
10096  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
10097  }
10098  arg13 = (PLINT)(val13);
10099  ecode14 = SWIG_AsVal_int(args(11), &val14);
10100  if (!SWIG_IsOK(ecode14)) {
10101  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
10102  }
10103  arg14 = (PLINT)(val14);
10104  ecode15 = SWIG_AsVal_int(args(12), &val15);
10105  if (!SWIG_IsOK(ecode15)) {
10106  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
10107  }
10108  arg15 = (PLINT)(val15);
10109  ecode16 = SWIG_AsVal_int(args(13), &val16);
10110  if (!SWIG_IsOK(ecode16)) {
10111  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
10112  }
10113  arg16 = (PLINT)(val16);
10114  ecode17 = SWIG_AsVal_int(args(14), &val17);
10115  if (!SWIG_IsOK(ecode17)) {
10116  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
10117  }
10118  arg17 = (PLINT)(val17);
10119  ecode18 = SWIG_AsVal_int(args(15), &val18);
10120  if (!SWIG_IsOK(ecode18)) {
10121  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
10122  }
10123  arg18 = (PLBOOL)(val18);
10124  {
10125  if ( _n_dims( args(16) ) > 1 )
10126  {
10127  error( "argument must be a scalar or vector" ); SWIG_fail;
10128  }
10129  if ( _dim( args(16), 0 ) != 6 )
10130  {
10131  error( "argument vectors must have length of 6" ); SWIG_fail;
10132  }
10133  temp19 = args(16).matrix_value();
10134  arg19 = &temp19( 0, 0 );
10135  }
10136  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);
10137  _outv = octave_value();
10138  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10139  {
10140 
10141  }
10142  {
10143 
10144  }
10145  {
10146 
10147  }
10148  return _out;
10149 fail:
10150  {
10151 
10152  }
10153  {
10154 
10155  }
10156  {
10157 
10158  }
10159  return octave_value_list();
10160 }
10161 
10162 
10163 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
10164  PLFLT *arg1 = (PLFLT *) 0 ;
10165  PLINT arg2 ;
10166  PLINT arg3 ;
10167  char *arg4 = (char *) 0 ;
10168  PLFLT arg5 ;
10169  PLFLT arg6 ;
10170  PLFLT arg7 ;
10171  PLFLT arg8 ;
10172  PLFLT arg9 ;
10173  PLFLT arg10 ;
10174  PLINT arg11 ;
10175  PLFLT arg12 ;
10176  PLINT arg13 ;
10177  PLINT arg14 ;
10178  PLINT arg15 ;
10179  PLINT arg16 ;
10180  PLINT arg17 ;
10181  PLBOOL arg18 ;
10182  PLFLT *arg19 = (PLFLT *) 0 ;
10183  PLFLT *arg20 = (PLFLT *) 0 ;
10184  Matrix temp1 ;
10185  int res4 ;
10186  char *buf4 = 0 ;
10187  int alloc4 = 0 ;
10188  double val5 ;
10189  int ecode5 = 0 ;
10190  double val6 ;
10191  int ecode6 = 0 ;
10192  double val7 ;
10193  int ecode7 = 0 ;
10194  double val8 ;
10195  int ecode8 = 0 ;
10196  double val9 ;
10197  int ecode9 = 0 ;
10198  double val10 ;
10199  int ecode10 = 0 ;
10200  int val11 ;
10201  int ecode11 = 0 ;
10202  double val12 ;
10203  int ecode12 = 0 ;
10204  int val13 ;
10205  int ecode13 = 0 ;
10206  int val14 ;
10207  int ecode14 = 0 ;
10208  int val15 ;
10209  int ecode15 = 0 ;
10210  int val16 ;
10211  int ecode16 = 0 ;
10212  int val17 ;
10213  int ecode17 = 0 ;
10214  int val18 ;
10215  int ecode18 = 0 ;
10216  Matrix temp19 ;
10217  Matrix temp20 ;
10218  octave_value_list _out;
10219  octave_value_list *_outp=&_out;
10220  octave_value _outv;
10221 
10222  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
10223  SWIG_fail;
10224  }
10225  {
10226  if ( _n_dims( args(0) ) > 2 )
10227  {
10228  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10229  }
10230  temp1 = args(0).matrix_value();
10231  arg1 = &temp1( 0, 0 );
10232  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10233  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10234  }
10235  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10236  if (!SWIG_IsOK(res4)) {
10237  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
10238  }
10239  arg4 = (char *)(buf4);
10240  ecode5 = SWIG_AsVal_double(args(2), &val5);
10241  if (!SWIG_IsOK(ecode5)) {
10242  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
10243  }
10244  arg5 = (PLFLT)(val5);
10245  ecode6 = SWIG_AsVal_double(args(3), &val6);
10246  if (!SWIG_IsOK(ecode6)) {
10247  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
10248  }
10249  arg6 = (PLFLT)(val6);
10250  ecode7 = SWIG_AsVal_double(args(4), &val7);
10251  if (!SWIG_IsOK(ecode7)) {
10252  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
10253  }
10254  arg7 = (PLFLT)(val7);
10255  ecode8 = SWIG_AsVal_double(args(5), &val8);
10256  if (!SWIG_IsOK(ecode8)) {
10257  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
10258  }
10259  arg8 = (PLFLT)(val8);
10260  ecode9 = SWIG_AsVal_double(args(6), &val9);
10261  if (!SWIG_IsOK(ecode9)) {
10262  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
10263  }
10264  arg9 = (PLFLT)(val9);
10265  ecode10 = SWIG_AsVal_double(args(7), &val10);
10266  if (!SWIG_IsOK(ecode10)) {
10267  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
10268  }
10269  arg10 = (PLFLT)(val10);
10270  ecode11 = SWIG_AsVal_int(args(8), &val11);
10271  if (!SWIG_IsOK(ecode11)) {
10272  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
10273  }
10274  arg11 = (PLINT)(val11);
10275  ecode12 = SWIG_AsVal_double(args(9), &val12);
10276  if (!SWIG_IsOK(ecode12)) {
10277  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
10278  }
10279  arg12 = (PLFLT)(val12);
10280  ecode13 = SWIG_AsVal_int(args(10), &val13);
10281  if (!SWIG_IsOK(ecode13)) {
10282  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
10283  }
10284  arg13 = (PLINT)(val13);
10285  ecode14 = SWIG_AsVal_int(args(11), &val14);
10286  if (!SWIG_IsOK(ecode14)) {
10287  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
10288  }
10289  arg14 = (PLINT)(val14);
10290  ecode15 = SWIG_AsVal_int(args(12), &val15);
10291  if (!SWIG_IsOK(ecode15)) {
10292  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
10293  }
10294  arg15 = (PLINT)(val15);
10295  ecode16 = SWIG_AsVal_int(args(13), &val16);
10296  if (!SWIG_IsOK(ecode16)) {
10297  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
10298  }
10299  arg16 = (PLINT)(val16);
10300  ecode17 = SWIG_AsVal_int(args(14), &val17);
10301  if (!SWIG_IsOK(ecode17)) {
10302  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
10303  }
10304  arg17 = (PLINT)(val17);
10305  ecode18 = SWIG_AsVal_int(args(15), &val18);
10306  if (!SWIG_IsOK(ecode18)) {
10307  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
10308  }
10309  arg18 = (PLBOOL)(val18);
10310  {
10311  if ( _n_dims( args(16) ) > 1 )
10312  {
10313  error( "argument must be a scalar or vector" ); SWIG_fail;
10314  }
10315  if ( _dim( args(16), 0 ) != Xlen )
10316  {
10317  error( "argument vectors must be same length" ); SWIG_fail;
10318  }
10319  temp19 = args(16).matrix_value();
10320  arg19 = &temp19( 0, 0 );
10321  }
10322  {
10323  if ( _n_dims( args(17) ) > 1 )
10324  {
10325  error( "argument must be a scalar or vector" ); SWIG_fail;
10326  }
10327  if ( _dim( args(17), 0 ) != Ylen )
10328  {
10329  error( "argument vectors must be same length" ); SWIG_fail;
10330  }
10331  temp20 = args(17).matrix_value();
10332  arg20 = &temp20( 0, 0 );
10333  }
10334  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);
10335  _outv = octave_value();
10336  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10337  {
10338 
10339  }
10340  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10341  {
10342 
10343  }
10344  {
10345 
10346  }
10347  return _out;
10348 fail:
10349  {
10350 
10351  }
10352  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10353  {
10354 
10355  }
10356  {
10357 
10358  }
10359  return octave_value_list();
10360 }
10361 
10362 
10363 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
10364  PLFLT *arg1 = (PLFLT *) 0 ;
10365  PLINT arg2 ;
10366  PLINT arg3 ;
10367  char *arg4 = (char *) 0 ;
10368  PLFLT arg5 ;
10369  PLFLT arg6 ;
10370  PLFLT arg7 ;
10371  PLFLT arg8 ;
10372  PLFLT arg9 ;
10373  PLFLT arg10 ;
10374  PLINT arg11 ;
10375  PLFLT arg12 ;
10376  PLINT arg13 ;
10377  PLINT arg14 ;
10378  PLINT arg15 ;
10379  PLINT arg16 ;
10380  PLINT arg17 ;
10381  PLBOOL arg18 ;
10382  PLFLT *arg19 = (PLFLT *) 0 ;
10383  PLFLT *arg20 = (PLFLT *) 0 ;
10384  Matrix temp1 ;
10385  int res4 ;
10386  char *buf4 = 0 ;
10387  int alloc4 = 0 ;
10388  double val5 ;
10389  int ecode5 = 0 ;
10390  double val6 ;
10391  int ecode6 = 0 ;
10392  double val7 ;
10393  int ecode7 = 0 ;
10394  double val8 ;
10395  int ecode8 = 0 ;
10396  double val9 ;
10397  int ecode9 = 0 ;
10398  double val10 ;
10399  int ecode10 = 0 ;
10400  int val11 ;
10401  int ecode11 = 0 ;
10402  double val12 ;
10403  int ecode12 = 0 ;
10404  int val13 ;
10405  int ecode13 = 0 ;
10406  int val14 ;
10407  int ecode14 = 0 ;
10408  int val15 ;
10409  int ecode15 = 0 ;
10410  int val16 ;
10411  int ecode16 = 0 ;
10412  int val17 ;
10413  int ecode17 = 0 ;
10414  int val18 ;
10415  int ecode18 = 0 ;
10416  Matrix temp19 ;
10417  Matrix temp20 ;
10418  octave_value_list _out;
10419  octave_value_list *_outp=&_out;
10420  octave_value _outv;
10421 
10422  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
10423  SWIG_fail;
10424  }
10425  {
10426  if ( _n_dims( args(0) ) > 2 )
10427  {
10428  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10429  }
10430  temp1 = args(0).matrix_value();
10431  arg1 = &temp1( 0, 0 );
10432  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10433  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10434  }
10435  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10436  if (!SWIG_IsOK(res4)) {
10437  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
10438  }
10439  arg4 = (char *)(buf4);
10440  ecode5 = SWIG_AsVal_double(args(2), &val5);
10441  if (!SWIG_IsOK(ecode5)) {
10442  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
10443  }
10444  arg5 = (PLFLT)(val5);
10445  ecode6 = SWIG_AsVal_double(args(3), &val6);
10446  if (!SWIG_IsOK(ecode6)) {
10447  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
10448  }
10449  arg6 = (PLFLT)(val6);
10450  ecode7 = SWIG_AsVal_double(args(4), &val7);
10451  if (!SWIG_IsOK(ecode7)) {
10452  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
10453  }
10454  arg7 = (PLFLT)(val7);
10455  ecode8 = SWIG_AsVal_double(args(5), &val8);
10456  if (!SWIG_IsOK(ecode8)) {
10457  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
10458  }
10459  arg8 = (PLFLT)(val8);
10460  ecode9 = SWIG_AsVal_double(args(6), &val9);
10461  if (!SWIG_IsOK(ecode9)) {
10462  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
10463  }
10464  arg9 = (PLFLT)(val9);
10465  ecode10 = SWIG_AsVal_double(args(7), &val10);
10466  if (!SWIG_IsOK(ecode10)) {
10467  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
10468  }
10469  arg10 = (PLFLT)(val10);
10470  ecode11 = SWIG_AsVal_int(args(8), &val11);
10471  if (!SWIG_IsOK(ecode11)) {
10472  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
10473  }
10474  arg11 = (PLINT)(val11);
10475  ecode12 = SWIG_AsVal_double(args(9), &val12);
10476  if (!SWIG_IsOK(ecode12)) {
10477  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
10478  }
10479  arg12 = (PLFLT)(val12);
10480  ecode13 = SWIG_AsVal_int(args(10), &val13);
10481  if (!SWIG_IsOK(ecode13)) {
10482  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
10483  }
10484  arg13 = (PLINT)(val13);
10485  ecode14 = SWIG_AsVal_int(args(11), &val14);
10486  if (!SWIG_IsOK(ecode14)) {
10487  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
10488  }
10489  arg14 = (PLINT)(val14);
10490  ecode15 = SWIG_AsVal_int(args(12), &val15);
10491  if (!SWIG_IsOK(ecode15)) {
10492  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
10493  }
10494  arg15 = (PLINT)(val15);
10495  ecode16 = SWIG_AsVal_int(args(13), &val16);
10496  if (!SWIG_IsOK(ecode16)) {
10497  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
10498  }
10499  arg16 = (PLINT)(val16);
10500  ecode17 = SWIG_AsVal_int(args(14), &val17);
10501  if (!SWIG_IsOK(ecode17)) {
10502  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
10503  }
10504  arg17 = (PLINT)(val17);
10505  ecode18 = SWIG_AsVal_int(args(15), &val18);
10506  if (!SWIG_IsOK(ecode18)) {
10507  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
10508  }
10509  arg18 = (PLBOOL)(val18);
10510  {
10511  if ( _n_dims( args(16) ) > 2 )
10512  {
10513  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10514  }
10515  temp19 = args(16).matrix_value();
10516  arg19 = &temp19( 0, 0 );
10517  Xlen = (PLINT) ( _dim( args(16), 0 ) );
10518  Ylen = (PLINT) ( _dim( args(16), 1 ) );
10519  }
10520  {
10521  if ( _n_dims( args(17) ) > 2 )
10522  {
10523  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10524  }
10525  temp20 = args(17).matrix_value();
10526  arg20 = &temp20( 0, 0 );
10527  Xlen = (PLINT) ( _dim( args(17), 0 ) );
10528  Ylen = (PLINT) ( _dim( args(17), 1 ) );
10529  }
10530  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);
10531  _outv = octave_value();
10532  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10533  {
10534 
10535  }
10536  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10537  {
10538 
10539  }
10540  {
10541 
10542  }
10543  return _out;
10544 fail:
10545  {
10546 
10547  }
10548  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10549  {
10550 
10551  }
10552  {
10553 
10554  }
10555  return octave_value_list();
10556 }
10557 
10558 
10559 SWIG_DEFUN( plshades, _wrap_plshades, std::string() ) {
10560  PLFLT *arg1 = (PLFLT *) 0 ;
10561  PLINT arg2 ;
10562  PLINT arg3 ;
10563  PLFLT arg4 ;
10564  PLFLT arg5 ;
10565  PLFLT arg6 ;
10566  PLFLT arg7 ;
10567  PLFLT *arg8 = (PLFLT *) 0 ;
10568  PLINT arg9 ;
10569  PLINT arg10 ;
10570  PLINT arg11 ;
10571  PLINT arg12 ;
10572  PLBOOL arg13 ;
10573  Matrix temp1 ;
10574  double val4 ;
10575  int ecode4 = 0 ;
10576  double val5 ;
10577  int ecode5 = 0 ;
10578  double val6 ;
10579  int ecode6 = 0 ;
10580  double val7 ;
10581  int ecode7 = 0 ;
10582  Matrix temp8 ;
10583  int val10 ;
10584  int ecode10 = 0 ;
10585  int val11 ;
10586  int ecode11 = 0 ;
10587  int val12 ;
10588  int ecode12 = 0 ;
10589  int val13 ;
10590  int ecode13 = 0 ;
10591  octave_value_list _out;
10592  octave_value_list *_outp=&_out;
10593  octave_value _outv;
10594 
10595  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
10596  SWIG_fail;
10597  }
10598  {
10599  if ( _n_dims( args(0) ) > 2 )
10600  {
10601  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10602  }
10603  temp1 = args(0).matrix_value();
10604  arg1 = &temp1( 0, 0 );
10605  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10606  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10607  }
10608  ecode4 = SWIG_AsVal_double(args(1), &val4);
10609  if (!SWIG_IsOK(ecode4)) {
10610  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
10611  }
10612  arg4 = (PLFLT)(val4);
10613  ecode5 = SWIG_AsVal_double(args(2), &val5);
10614  if (!SWIG_IsOK(ecode5)) {
10615  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
10616  }
10617  arg5 = (PLFLT)(val5);
10618  ecode6 = SWIG_AsVal_double(args(3), &val6);
10619  if (!SWIG_IsOK(ecode6)) {
10620  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
10621  }
10622  arg6 = (PLFLT)(val6);
10623  ecode7 = SWIG_AsVal_double(args(4), &val7);
10624  if (!SWIG_IsOK(ecode7)) {
10625  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
10626  }
10627  arg7 = (PLFLT)(val7);
10628  {
10629  if ( _n_dims( args(5) ) > 1 )
10630  {
10631  error( "argument must be a scalar or vector" ); SWIG_fail;
10632  }
10633  temp8 = args(5).matrix_value();
10634  arg8 = &temp8( 0, 0 );
10635  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10636  }
10637  ecode10 = SWIG_AsVal_int(args(6), &val10);
10638  if (!SWIG_IsOK(ecode10)) {
10639  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
10640  }
10641  arg10 = (PLINT)(val10);
10642  ecode11 = SWIG_AsVal_int(args(7), &val11);
10643  if (!SWIG_IsOK(ecode11)) {
10644  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
10645  }
10646  arg11 = (PLINT)(val11);
10647  ecode12 = SWIG_AsVal_int(args(8), &val12);
10648  if (!SWIG_IsOK(ecode12)) {
10649  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
10650  }
10651  arg12 = (PLINT)(val12);
10652  ecode13 = SWIG_AsVal_int(args(9), &val13);
10653  if (!SWIG_IsOK(ecode13)) {
10654  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
10655  }
10656  arg13 = (PLBOOL)(val13);
10657  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
10658  _outv = octave_value();
10659  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10660  {
10661 
10662  }
10663  {
10664 
10665  }
10666  return _out;
10667 fail:
10668  {
10669 
10670  }
10671  {
10672 
10673  }
10674  return octave_value_list();
10675 }
10676 
10677 
10678 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
10679  PLFLT *arg1 = (PLFLT *) 0 ;
10680  PLINT arg2 ;
10681  PLINT arg3 ;
10682  PLFLT arg4 ;
10683  PLFLT arg5 ;
10684  PLFLT arg6 ;
10685  PLFLT arg7 ;
10686  PLFLT *arg8 = (PLFLT *) 0 ;
10687  PLINT arg9 ;
10688  PLINT arg10 ;
10689  PLINT arg11 ;
10690  PLINT arg12 ;
10691  PLBOOL arg13 ;
10692  PLFLT *arg14 = (PLFLT *) 0 ;
10693  Matrix temp1 ;
10694  double val4 ;
10695  int ecode4 = 0 ;
10696  double val5 ;
10697  int ecode5 = 0 ;
10698  double val6 ;
10699  int ecode6 = 0 ;
10700  double val7 ;
10701  int ecode7 = 0 ;
10702  Matrix temp8 ;
10703  int val10 ;
10704  int ecode10 = 0 ;
10705  int val11 ;
10706  int ecode11 = 0 ;
10707  int val12 ;
10708  int ecode12 = 0 ;
10709  int val13 ;
10710  int ecode13 = 0 ;
10711  Matrix temp14 ;
10712  octave_value_list _out;
10713  octave_value_list *_outp=&_out;
10714  octave_value _outv;
10715 
10716  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 '" "plshadesx" "', 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 ) != 6 )
10784  {
10785  error( "argument vectors must have length of 6" ); SWIG_fail;
10786  }
10787  temp14 = args(10).matrix_value();
10788  arg14 = &temp14( 0, 0 );
10789  }
10790  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
10791  _outv = octave_value();
10792  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10793  {
10794 
10795  }
10796  {
10797 
10798  }
10799  {
10800 
10801  }
10802  return _out;
10803 fail:
10804  {
10805 
10806  }
10807  {
10808 
10809  }
10810  {
10811 
10812  }
10813  return octave_value_list();
10814 }
10815 
10816 
10817 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
10818  PLFLT *arg1 = (PLFLT *) 0 ;
10819  PLINT arg2 ;
10820  PLINT arg3 ;
10821  PLFLT arg4 ;
10822  PLFLT arg5 ;
10823  PLFLT arg6 ;
10824  PLFLT arg7 ;
10825  PLFLT *arg8 = (PLFLT *) 0 ;
10826  PLINT arg9 ;
10827  PLINT arg10 ;
10828  PLINT arg11 ;
10829  PLINT arg12 ;
10830  PLBOOL arg13 ;
10831  PLFLT *arg14 = (PLFLT *) 0 ;
10832  PLFLT *arg15 = (PLFLT *) 0 ;
10833  Matrix temp1 ;
10834  double val4 ;
10835  int ecode4 = 0 ;
10836  double val5 ;
10837  int ecode5 = 0 ;
10838  double val6 ;
10839  int ecode6 = 0 ;
10840  double val7 ;
10841  int ecode7 = 0 ;
10842  Matrix temp8 ;
10843  int val10 ;
10844  int ecode10 = 0 ;
10845  int val11 ;
10846  int ecode11 = 0 ;
10847  int val12 ;
10848  int ecode12 = 0 ;
10849  int val13 ;
10850  int ecode13 = 0 ;
10851  Matrix temp14 ;
10852  Matrix temp15 ;
10853  octave_value_list _out;
10854  octave_value_list *_outp=&_out;
10855  octave_value _outv;
10856 
10857  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
10858  SWIG_fail;
10859  }
10860  {
10861  if ( _n_dims( args(0) ) > 2 )
10862  {
10863  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10864  }
10865  temp1 = args(0).matrix_value();
10866  arg1 = &temp1( 0, 0 );
10867  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10868  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10869  }
10870  ecode4 = SWIG_AsVal_double(args(1), &val4);
10871  if (!SWIG_IsOK(ecode4)) {
10872  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
10873  }
10874  arg4 = (PLFLT)(val4);
10875  ecode5 = SWIG_AsVal_double(args(2), &val5);
10876  if (!SWIG_IsOK(ecode5)) {
10877  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
10878  }
10879  arg5 = (PLFLT)(val5);
10880  ecode6 = SWIG_AsVal_double(args(3), &val6);
10881  if (!SWIG_IsOK(ecode6)) {
10882  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
10883  }
10884  arg6 = (PLFLT)(val6);
10885  ecode7 = SWIG_AsVal_double(args(4), &val7);
10886  if (!SWIG_IsOK(ecode7)) {
10887  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
10888  }
10889  arg7 = (PLFLT)(val7);
10890  {
10891  if ( _n_dims( args(5) ) > 1 )
10892  {
10893  error( "argument must be a scalar or vector" ); SWIG_fail;
10894  }
10895  temp8 = args(5).matrix_value();
10896  arg8 = &temp8( 0, 0 );
10897  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10898  }
10899  ecode10 = SWIG_AsVal_int(args(6), &val10);
10900  if (!SWIG_IsOK(ecode10)) {
10901  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
10902  }
10903  arg10 = (PLINT)(val10);
10904  ecode11 = SWIG_AsVal_int(args(7), &val11);
10905  if (!SWIG_IsOK(ecode11)) {
10906  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
10907  }
10908  arg11 = (PLINT)(val11);
10909  ecode12 = SWIG_AsVal_int(args(8), &val12);
10910  if (!SWIG_IsOK(ecode12)) {
10911  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
10912  }
10913  arg12 = (PLINT)(val12);
10914  ecode13 = SWIG_AsVal_int(args(9), &val13);
10915  if (!SWIG_IsOK(ecode13)) {
10916  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
10917  }
10918  arg13 = (PLBOOL)(val13);
10919  {
10920  if ( _n_dims( args(10) ) > 1 )
10921  {
10922  error( "argument must be a scalar or vector" ); SWIG_fail;
10923  }
10924  if ( _dim( args(10), 0 ) != Xlen )
10925  {
10926  error( "argument vectors must be same length" ); SWIG_fail;
10927  }
10928  temp14 = args(10).matrix_value();
10929  arg14 = &temp14( 0, 0 );
10930  }
10931  {
10932  if ( _n_dims( args(11) ) > 1 )
10933  {
10934  error( "argument must be a scalar or vector" ); SWIG_fail;
10935  }
10936  if ( _dim( args(11), 0 ) != Ylen )
10937  {
10938  error( "argument vectors must be same length" ); SWIG_fail;
10939  }
10940  temp15 = args(11).matrix_value();
10941  arg15 = &temp15( 0, 0 );
10942  }
10943  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);
10944  _outv = octave_value();
10945  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10946  {
10947 
10948  }
10949  {
10950 
10951  }
10952  {
10953 
10954  }
10955  {
10956 
10957  }
10958  return _out;
10959 fail:
10960  {
10961 
10962  }
10963  {
10964 
10965  }
10966  {
10967 
10968  }
10969  {
10970 
10971  }
10972  return octave_value_list();
10973 }
10974 
10975 
10976 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
10977  PLFLT *arg1 = (PLFLT *) 0 ;
10978  PLINT arg2 ;
10979  PLINT arg3 ;
10980  PLFLT arg4 ;
10981  PLFLT arg5 ;
10982  PLFLT arg6 ;
10983  PLFLT arg7 ;
10984  PLFLT *arg8 = (PLFLT *) 0 ;
10985  PLINT arg9 ;
10986  PLINT arg10 ;
10987  PLINT arg11 ;
10988  PLINT arg12 ;
10989  PLBOOL arg13 ;
10990  PLFLT *arg14 = (PLFLT *) 0 ;
10991  PLFLT *arg15 = (PLFLT *) 0 ;
10992  Matrix temp1 ;
10993  double val4 ;
10994  int ecode4 = 0 ;
10995  double val5 ;
10996  int ecode5 = 0 ;
10997  double val6 ;
10998  int ecode6 = 0 ;
10999  double val7 ;
11000  int ecode7 = 0 ;
11001  Matrix temp8 ;
11002  int val10 ;
11003  int ecode10 = 0 ;
11004  int val11 ;
11005  int ecode11 = 0 ;
11006  int val12 ;
11007  int ecode12 = 0 ;
11008  int val13 ;
11009  int ecode13 = 0 ;
11010  Matrix temp14 ;
11011  Matrix temp15 ;
11012  octave_value_list _out;
11013  octave_value_list *_outp=&_out;
11014  octave_value _outv;
11015 
11016  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
11017  SWIG_fail;
11018  }
11019  {
11020  if ( _n_dims( args(0) ) > 2 )
11021  {
11022  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11023  }
11024  temp1 = args(0).matrix_value();
11025  arg1 = &temp1( 0, 0 );
11026  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11027  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11028  }
11029  ecode4 = SWIG_AsVal_double(args(1), &val4);
11030  if (!SWIG_IsOK(ecode4)) {
11031  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
11032  }
11033  arg4 = (PLFLT)(val4);
11034  ecode5 = SWIG_AsVal_double(args(2), &val5);
11035  if (!SWIG_IsOK(ecode5)) {
11036  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
11037  }
11038  arg5 = (PLFLT)(val5);
11039  ecode6 = SWIG_AsVal_double(args(3), &val6);
11040  if (!SWIG_IsOK(ecode6)) {
11041  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
11042  }
11043  arg6 = (PLFLT)(val6);
11044  ecode7 = SWIG_AsVal_double(args(4), &val7);
11045  if (!SWIG_IsOK(ecode7)) {
11046  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
11047  }
11048  arg7 = (PLFLT)(val7);
11049  {
11050  if ( _n_dims( args(5) ) > 1 )
11051  {
11052  error( "argument must be a scalar or vector" ); SWIG_fail;
11053  }
11054  temp8 = args(5).matrix_value();
11055  arg8 = &temp8( 0, 0 );
11056  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11057  }
11058  ecode10 = SWIG_AsVal_int(args(6), &val10);
11059  if (!SWIG_IsOK(ecode10)) {
11060  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
11061  }
11062  arg10 = (PLINT)(val10);
11063  ecode11 = SWIG_AsVal_int(args(7), &val11);
11064  if (!SWIG_IsOK(ecode11)) {
11065  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
11066  }
11067  arg11 = (PLINT)(val11);
11068  ecode12 = SWIG_AsVal_int(args(8), &val12);
11069  if (!SWIG_IsOK(ecode12)) {
11070  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
11071  }
11072  arg12 = (PLINT)(val12);
11073  ecode13 = SWIG_AsVal_int(args(9), &val13);
11074  if (!SWIG_IsOK(ecode13)) {
11075  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
11076  }
11077  arg13 = (PLBOOL)(val13);
11078  {
11079  if ( _n_dims( args(10) ) > 2 )
11080  {
11081  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11082  }
11083  temp14 = args(10).matrix_value();
11084  arg14 = &temp14( 0, 0 );
11085  Xlen = (PLINT) ( _dim( args(10), 0 ) );
11086  Ylen = (PLINT) ( _dim( args(10), 1 ) );
11087  }
11088  {
11089  if ( _n_dims( args(11) ) > 2 )
11090  {
11091  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11092  }
11093  temp15 = args(11).matrix_value();
11094  arg15 = &temp15( 0, 0 );
11095  Xlen = (PLINT) ( _dim( args(11), 0 ) );
11096  Ylen = (PLINT) ( _dim( args(11), 1 ) );
11097  }
11098  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);
11099  _outv = octave_value();
11100  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11101  {
11102 
11103  }
11104  {
11105 
11106  }
11107  {
11108 
11109  }
11110  {
11111 
11112  }
11113  return _out;
11114 fail:
11115  {
11116 
11117  }
11118  {
11119 
11120  }
11121  {
11122 
11123  }
11124  {
11125 
11126  }
11127  return octave_value_list();
11128 }
11129 
11130 
11131 SWIG_DEFUN( plvect, _wrap_plvect, std::string() ) {
11132  PLFLT *arg1 = (PLFLT *) 0 ;
11133  PLFLT *arg2 = (PLFLT *) 0 ;
11134  PLINT arg3 ;
11135  PLINT arg4 ;
11136  PLFLT arg5 ;
11137  PLFLT *arg6 = (PLFLT *) 0 ;
11138  Matrix temp1 ;
11139  Matrix temp2 ;
11140  double val5 ;
11141  int ecode5 = 0 ;
11142  Matrix temp6 ;
11143  octave_value_list _out;
11144  octave_value_list *_outp=&_out;
11145  octave_value _outv;
11146 
11147  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
11148  SWIG_fail;
11149  }
11150  {
11151  if ( _n_dims( args(0) ) > 2 )
11152  {
11153  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11154  }
11155  temp1 = args(0).matrix_value();
11156  arg1 = &temp1( 0, 0 );
11157  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11158  Ylen = (PLINT) ( _dim( args(0), 1 ) );
11159  }
11160  {
11161  if ( _n_dims( args(1) ) > 2 )
11162  {
11163  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11164  }
11165  if ( _dim( args(1), 0 ) != Xlen )
11166  {
11167  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11168  }
11169  if ( _dim( args(1), 1 ) != Ylen )
11170  {
11171  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11172  }
11173  temp2 = args(1).matrix_value();
11174  arg2 = &temp2( 0, 0 );
11175  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11176  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11177  }
11178  ecode5 = SWIG_AsVal_double(args(2), &val5);
11179  if (!SWIG_IsOK(ecode5)) {
11180  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
11181  }
11182  arg5 = (PLFLT)(val5);
11183  {
11184  if ( _n_dims( args(3) ) > 1 )
11185  {
11186  error( "argument must be a scalar or vector" ); SWIG_fail;
11187  }
11188  if ( _dim( args(3), 0 ) != 6 )
11189  {
11190  error( "argument vectors must have length of 6" ); SWIG_fail;
11191  }
11192  temp6 = args(3).matrix_value();
11193  arg6 = &temp6( 0, 0 );
11194  }
11195  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
11196  _outv = octave_value();
11197  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11198  {
11199 
11200  }
11201  {
11202 
11203  }
11204  {
11205 
11206  }
11207  return _out;
11208 fail:
11209  {
11210 
11211  }
11212  {
11213 
11214  }
11215  {
11216 
11217  }
11218  return octave_value_list();
11219 }
11220 
11221 
11222 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
11223  PLFLT *arg1 = (PLFLT *) 0 ;
11224  PLFLT *arg2 = (PLFLT *) 0 ;
11225  PLINT arg3 ;
11226  PLINT arg4 ;
11227  PLFLT arg5 ;
11228  PLFLT *arg6 = (PLFLT *) 0 ;
11229  PLFLT *arg7 = (PLFLT *) 0 ;
11230  Matrix temp1 ;
11231  Matrix temp2 ;
11232  double val5 ;
11233  int ecode5 = 0 ;
11234  Matrix temp6 ;
11235  Matrix temp7 ;
11236  octave_value_list _out;
11237  octave_value_list *_outp=&_out;
11238  octave_value _outv;
11239 
11240  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
11241  SWIG_fail;
11242  }
11243  {
11244  if ( _n_dims( args(0) ) > 2 )
11245  {
11246  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11247  }
11248  temp1 = args(0).matrix_value();
11249  arg1 = &temp1( 0, 0 );
11250  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11251  Ylen = (PLINT) ( _dim( args(0), 1 ) );
11252  }
11253  {
11254  if ( _n_dims( args(1) ) > 2 )
11255  {
11256  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11257  }
11258  if ( _dim( args(1), 0 ) != Xlen )
11259  {
11260  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11261  }
11262  if ( _dim( args(1), 1 ) != Ylen )
11263  {
11264  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11265  }
11266  temp2 = args(1).matrix_value();
11267  arg2 = &temp2( 0, 0 );
11268  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11269  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11270  }
11271  ecode5 = SWIG_AsVal_double(args(2), &val5);
11272  if (!SWIG_IsOK(ecode5)) {
11273  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
11274  }
11275  arg5 = (PLFLT)(val5);
11276  {
11277  if ( _n_dims( args(3) ) > 1 )
11278  {
11279  error( "argument must be a scalar or vector" ); SWIG_fail;
11280  }
11281  if ( _dim( args(3), 0 ) != Xlen )
11282  {
11283  error( "argument vectors must be same length" ); SWIG_fail;
11284  }
11285  temp6 = args(3).matrix_value();
11286  arg6 = &temp6( 0, 0 );
11287  }
11288  {
11289  if ( _n_dims( args(4) ) > 1 )
11290  {
11291  error( "argument must be a scalar or vector" ); SWIG_fail;
11292  }
11293  if ( _dim( args(4), 0 ) != Ylen )
11294  {
11295  error( "argument vectors must be same length" ); SWIG_fail;
11296  }
11297  temp7 = args(4).matrix_value();
11298  arg7 = &temp7( 0, 0 );
11299  }
11300  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
11301  _outv = octave_value();
11302  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11303  {
11304 
11305  }
11306  {
11307 
11308  }
11309  {
11310 
11311  }
11312  {
11313 
11314  }
11315  return _out;
11316 fail:
11317  {
11318 
11319  }
11320  {
11321 
11322  }
11323  {
11324 
11325  }
11326  {
11327 
11328  }
11329  return octave_value_list();
11330 }
11331 
11332 
11333 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
11334  PLFLT *arg1 = (PLFLT *) 0 ;
11335  PLFLT *arg2 = (PLFLT *) 0 ;
11336  PLINT arg3 ;
11337  PLINT arg4 ;
11338  PLFLT arg5 ;
11339  PLFLT *arg6 = (PLFLT *) 0 ;
11340  PLFLT *arg7 = (PLFLT *) 0 ;
11341  Matrix temp1 ;
11342  Matrix temp2 ;
11343  double val5 ;
11344  int ecode5 = 0 ;
11345  Matrix temp6 ;
11346  Matrix temp7 ;
11347  octave_value_list _out;
11348  octave_value_list *_outp=&_out;
11349  octave_value _outv;
11350 
11351  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
11352  SWIG_fail;
11353  }
11354  {
11355  if ( _n_dims( args(0) ) > 2 )
11356  {
11357  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11358  }
11359  temp1 = args(0).matrix_value();
11360  arg1 = &temp1( 0, 0 );
11361  Xlen = (PLINT) ( _dim( args(0), 0 ) );
11362  Ylen = (PLINT) ( _dim( args(0), 1 ) );
11363  }
11364  {
11365  if ( _n_dims( args(1) ) > 2 )
11366  {
11367  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11368  }
11369  if ( _dim( args(1), 0 ) != Xlen )
11370  {
11371  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11372  }
11373  if ( _dim( args(1), 1 ) != Ylen )
11374  {
11375  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11376  }
11377  temp2 = args(1).matrix_value();
11378  arg2 = &temp2( 0, 0 );
11379  arg3 = (PLINT) ( _dim( args(1), 0 ) );
11380  arg4 = (PLINT) ( _dim( args(1), 1 ) );
11381  }
11382  ecode5 = SWIG_AsVal_double(args(2), &val5);
11383  if (!SWIG_IsOK(ecode5)) {
11384  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
11385  }
11386  arg5 = (PLFLT)(val5);
11387  {
11388  if ( _n_dims( args(3) ) > 2 )
11389  {
11390  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11391  }
11392  temp6 = args(3).matrix_value();
11393  arg6 = &temp6( 0, 0 );
11394  Xlen = (PLINT) ( _dim( args(3), 0 ) );
11395  Ylen = (PLINT) ( _dim( args(3), 1 ) );
11396  }
11397  {
11398  if ( _n_dims( args(4) ) > 2 )
11399  {
11400  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11401  }
11402  temp7 = args(4).matrix_value();
11403  arg7 = &temp7( 0, 0 );
11404  Xlen = (PLINT) ( _dim( args(4), 0 ) );
11405  Ylen = (PLINT) ( _dim( args(4), 1 ) );
11406  }
11407  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
11408  _outv = octave_value();
11409  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11410  {
11411 
11412  }
11413  {
11414 
11415  }
11416  {
11417 
11418  }
11419  {
11420 
11421  }
11422  return _out;
11423 fail:
11424  {
11425 
11426  }
11427  {
11428 
11429  }
11430  {
11431 
11432  }
11433  {
11434 
11435  }
11436  return octave_value_list();
11437 }
11438 
11439 
11440 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
11441  PLFLT *arg1 = (PLFLT *) 0 ;
11442  PLINT arg2 ;
11443  PLINT arg3 ;
11444  PLFLT arg4 ;
11445  PLFLT arg5 ;
11446  PLFLT arg6 ;
11447  PLFLT arg7 ;
11448  PLFLT arg8 ;
11449  PLFLT arg9 ;
11450  PLFLT arg10 ;
11451  PLFLT arg11 ;
11452  PLFLT arg12 ;
11453  PLFLT arg13 ;
11454  Matrix temp1 ;
11455  double val4 ;
11456  int ecode4 = 0 ;
11457  double val5 ;
11458  int ecode5 = 0 ;
11459  double val6 ;
11460  int ecode6 = 0 ;
11461  double val7 ;
11462  int ecode7 = 0 ;
11463  double val8 ;
11464  int ecode8 = 0 ;
11465  double val9 ;
11466  int ecode9 = 0 ;
11467  double val10 ;
11468  int ecode10 = 0 ;
11469  double val11 ;
11470  int ecode11 = 0 ;
11471  double val12 ;
11472  int ecode12 = 0 ;
11473  double val13 ;
11474  int ecode13 = 0 ;
11475  octave_value_list _out;
11476  octave_value_list *_outp=&_out;
11477  octave_value _outv;
11478 
11479  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
11480  SWIG_fail;
11481  }
11482  {
11483  if ( _n_dims( args(0) ) > 2 )
11484  {
11485  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11486  }
11487  temp1 = args(0).matrix_value();
11488  arg1 = &temp1( 0, 0 );
11489  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11490  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11491  }
11492  ecode4 = SWIG_AsVal_double(args(1), &val4);
11493  if (!SWIG_IsOK(ecode4)) {
11494  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
11495  }
11496  arg4 = (PLFLT)(val4);
11497  ecode5 = SWIG_AsVal_double(args(2), &val5);
11498  if (!SWIG_IsOK(ecode5)) {
11499  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
11500  }
11501  arg5 = (PLFLT)(val5);
11502  ecode6 = SWIG_AsVal_double(args(3), &val6);
11503  if (!SWIG_IsOK(ecode6)) {
11504  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
11505  }
11506  arg6 = (PLFLT)(val6);
11507  ecode7 = SWIG_AsVal_double(args(4), &val7);
11508  if (!SWIG_IsOK(ecode7)) {
11509  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
11510  }
11511  arg7 = (PLFLT)(val7);
11512  ecode8 = SWIG_AsVal_double(args(5), &val8);
11513  if (!SWIG_IsOK(ecode8)) {
11514  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
11515  }
11516  arg8 = (PLFLT)(val8);
11517  ecode9 = SWIG_AsVal_double(args(6), &val9);
11518  if (!SWIG_IsOK(ecode9)) {
11519  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
11520  }
11521  arg9 = (PLFLT)(val9);
11522  ecode10 = SWIG_AsVal_double(args(7), &val10);
11523  if (!SWIG_IsOK(ecode10)) {
11524  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
11525  }
11526  arg10 = (PLFLT)(val10);
11527  ecode11 = SWIG_AsVal_double(args(8), &val11);
11528  if (!SWIG_IsOK(ecode11)) {
11529  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
11530  }
11531  arg11 = (PLFLT)(val11);
11532  ecode12 = SWIG_AsVal_double(args(9), &val12);
11533  if (!SWIG_IsOK(ecode12)) {
11534  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
11535  }
11536  arg12 = (PLFLT)(val12);
11537  ecode13 = SWIG_AsVal_double(args(10), &val13);
11538  if (!SWIG_IsOK(ecode13)) {
11539  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
11540  }
11541  arg13 = (PLFLT)(val13);
11542  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
11543  _outv = octave_value();
11544  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11545  {
11546 
11547  }
11548  return _out;
11549 fail:
11550  {
11551 
11552  }
11553  return octave_value_list();
11554 }
11555 
11556 
11558  PLFLT *arg1 = (PLFLT *) 0 ;
11559  PLINT arg2 ;
11560  PLINT arg3 ;
11561  PLFLT arg4 ;
11562  PLFLT arg5 ;
11563  PLFLT arg6 ;
11564  PLFLT arg7 ;
11565  PLFLT arg8 ;
11566  PLFLT arg9 ;
11567  PLFLT arg10 ;
11568  PLFLT arg11 ;
11569  Matrix temp1 ;
11570  double val4 ;
11571  int ecode4 = 0 ;
11572  double val5 ;
11573  int ecode5 = 0 ;
11574  double val6 ;
11575  int ecode6 = 0 ;
11576  double val7 ;
11577  int ecode7 = 0 ;
11578  double val8 ;
11579  int ecode8 = 0 ;
11580  double val9 ;
11581  int ecode9 = 0 ;
11582  double val10 ;
11583  int ecode10 = 0 ;
11584  double val11 ;
11585  int ecode11 = 0 ;
11586  octave_value_list _out;
11587  octave_value_list *_outp=&_out;
11588  octave_value _outv;
11589 
11590  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
11591  SWIG_fail;
11592  }
11593  {
11594  if ( _n_dims( args(0) ) > 2 )
11595  {
11596  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11597  }
11598  temp1 = args(0).matrix_value();
11599  arg1 = &temp1( 0, 0 );
11600  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11601  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11602  }
11603  ecode4 = SWIG_AsVal_double(args(1), &val4);
11604  if (!SWIG_IsOK(ecode4)) {
11605  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
11606  }
11607  arg4 = (PLFLT)(val4);
11608  ecode5 = SWIG_AsVal_double(args(2), &val5);
11609  if (!SWIG_IsOK(ecode5)) {
11610  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
11611  }
11612  arg5 = (PLFLT)(val5);
11613  ecode6 = SWIG_AsVal_double(args(3), &val6);
11614  if (!SWIG_IsOK(ecode6)) {
11615  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
11616  }
11617  arg6 = (PLFLT)(val6);
11618  ecode7 = SWIG_AsVal_double(args(4), &val7);
11619  if (!SWIG_IsOK(ecode7)) {
11620  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
11621  }
11622  arg7 = (PLFLT)(val7);
11623  ecode8 = SWIG_AsVal_double(args(5), &val8);
11624  if (!SWIG_IsOK(ecode8)) {
11625  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
11626  }
11627  arg8 = (PLFLT)(val8);
11628  ecode9 = SWIG_AsVal_double(args(6), &val9);
11629  if (!SWIG_IsOK(ecode9)) {
11630  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
11631  }
11632  arg9 = (PLFLT)(val9);
11633  ecode10 = SWIG_AsVal_double(args(7), &val10);
11634  if (!SWIG_IsOK(ecode10)) {
11635  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
11636  }
11637  arg10 = (PLFLT)(val10);
11638  ecode11 = SWIG_AsVal_double(args(8), &val11);
11639  if (!SWIG_IsOK(ecode11)) {
11640  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
11641  }
11642  arg11 = (PLFLT)(val11);
11643  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11644  _outv = octave_value();
11645  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11646  {
11647 
11648  }
11649  return _out;
11650 fail:
11651  {
11652 
11653  }
11654  return octave_value_list();
11655 }
11656 
11657 
11658 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
11659  PLFLT *arg1 = (PLFLT *) 0 ;
11660  PLINT arg2 ;
11661  PLINT arg3 ;
11662  PLFLT arg4 ;
11663  PLFLT arg5 ;
11664  PLFLT arg6 ;
11665  PLFLT arg7 ;
11666  PLFLT arg8 ;
11667  PLFLT arg9 ;
11668  PLFLT arg10 ;
11669  PLFLT arg11 ;
11670  PLFLT *arg12 = (PLFLT *) 0 ;
11671  Matrix temp1 ;
11672  double val4 ;
11673  int ecode4 = 0 ;
11674  double val5 ;
11675  int ecode5 = 0 ;
11676  double val6 ;
11677  int ecode6 = 0 ;
11678  double val7 ;
11679  int ecode7 = 0 ;
11680  double val8 ;
11681  int ecode8 = 0 ;
11682  double val9 ;
11683  int ecode9 = 0 ;
11684  double val10 ;
11685  int ecode10 = 0 ;
11686  double val11 ;
11687  int ecode11 = 0 ;
11688  Matrix temp12 ;
11689  octave_value_list _out;
11690  octave_value_list *_outp=&_out;
11691  octave_value _outv;
11692 
11693  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
11694  SWIG_fail;
11695  }
11696  {
11697  if ( _n_dims( args(0) ) > 2 )
11698  {
11699  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11700  }
11701  temp1 = args(0).matrix_value();
11702  arg1 = &temp1( 0, 0 );
11703  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11704  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11705  }
11706  ecode4 = SWIG_AsVal_double(args(1), &val4);
11707  if (!SWIG_IsOK(ecode4)) {
11708  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
11709  }
11710  arg4 = (PLFLT)(val4);
11711  ecode5 = SWIG_AsVal_double(args(2), &val5);
11712  if (!SWIG_IsOK(ecode5)) {
11713  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
11714  }
11715  arg5 = (PLFLT)(val5);
11716  ecode6 = SWIG_AsVal_double(args(3), &val6);
11717  if (!SWIG_IsOK(ecode6)) {
11718  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
11719  }
11720  arg6 = (PLFLT)(val6);
11721  ecode7 = SWIG_AsVal_double(args(4), &val7);
11722  if (!SWIG_IsOK(ecode7)) {
11723  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
11724  }
11725  arg7 = (PLFLT)(val7);
11726  ecode8 = SWIG_AsVal_double(args(5), &val8);
11727  if (!SWIG_IsOK(ecode8)) {
11728  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
11729  }
11730  arg8 = (PLFLT)(val8);
11731  ecode9 = SWIG_AsVal_double(args(6), &val9);
11732  if (!SWIG_IsOK(ecode9)) {
11733  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
11734  }
11735  arg9 = (PLFLT)(val9);
11736  ecode10 = SWIG_AsVal_double(args(7), &val10);
11737  if (!SWIG_IsOK(ecode10)) {
11738  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
11739  }
11740  arg10 = (PLFLT)(val10);
11741  ecode11 = SWIG_AsVal_double(args(8), &val11);
11742  if (!SWIG_IsOK(ecode11)) {
11743  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
11744  }
11745  arg11 = (PLFLT)(val11);
11746  {
11747  if ( _n_dims( args(9) ) > 1 )
11748  {
11749  error( "argument must be a scalar or vector" ); SWIG_fail;
11750  }
11751  if ( _dim( args(9), 0 ) != 6 )
11752  {
11753  error( "argument vectors must have length of 6" ); SWIG_fail;
11754  }
11755  temp12 = args(9).matrix_value();
11756  arg12 = &temp12( 0, 0 );
11757  }
11758  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
11759  _outv = octave_value();
11760  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11761  {
11762 
11763  }
11764  {
11765 
11766  }
11767  return _out;
11768 fail:
11769  {
11770 
11771  }
11772  {
11773 
11774  }
11775  return octave_value_list();
11776 }
11777 
11778 
11779 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
11780  PLFLT *arg1 = (PLFLT *) 0 ;
11781  PLINT arg2 ;
11782  PLINT arg3 ;
11783  PLFLT arg4 ;
11784  PLFLT arg5 ;
11785  PLFLT arg6 ;
11786  PLFLT arg7 ;
11787  PLFLT arg8 ;
11788  PLFLT arg9 ;
11789  PLFLT arg10 ;
11790  PLFLT arg11 ;
11791  PLFLT *arg12 = (PLFLT *) 0 ;
11792  PLFLT *arg13 = (PLFLT *) 0 ;
11793  Matrix temp1 ;
11794  double val4 ;
11795  int ecode4 = 0 ;
11796  double val5 ;
11797  int ecode5 = 0 ;
11798  double val6 ;
11799  int ecode6 = 0 ;
11800  double val7 ;
11801  int ecode7 = 0 ;
11802  double val8 ;
11803  int ecode8 = 0 ;
11804  double val9 ;
11805  int ecode9 = 0 ;
11806  double val10 ;
11807  int ecode10 = 0 ;
11808  double val11 ;
11809  int ecode11 = 0 ;
11810  Matrix temp12 ;
11811  Matrix temp13 ;
11812  octave_value_list _out;
11813  octave_value_list *_outp=&_out;
11814  octave_value _outv;
11815 
11816  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
11817  SWIG_fail;
11818  }
11819  {
11820  if ( _n_dims( args(0) ) > 2 )
11821  {
11822  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11823  }
11824  temp1 = args(0).matrix_value();
11825  arg1 = &temp1( 0, 0 );
11826  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11827  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11828  }
11829  ecode4 = SWIG_AsVal_double(args(1), &val4);
11830  if (!SWIG_IsOK(ecode4)) {
11831  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
11832  }
11833  arg4 = (PLFLT)(val4);
11834  ecode5 = SWIG_AsVal_double(args(2), &val5);
11835  if (!SWIG_IsOK(ecode5)) {
11836  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
11837  }
11838  arg5 = (PLFLT)(val5);
11839  ecode6 = SWIG_AsVal_double(args(3), &val6);
11840  if (!SWIG_IsOK(ecode6)) {
11841  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
11842  }
11843  arg6 = (PLFLT)(val6);
11844  ecode7 = SWIG_AsVal_double(args(4), &val7);
11845  if (!SWIG_IsOK(ecode7)) {
11846  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
11847  }
11848  arg7 = (PLFLT)(val7);
11849  ecode8 = SWIG_AsVal_double(args(5), &val8);
11850  if (!SWIG_IsOK(ecode8)) {
11851  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
11852  }
11853  arg8 = (PLFLT)(val8);
11854  ecode9 = SWIG_AsVal_double(args(6), &val9);
11855  if (!SWIG_IsOK(ecode9)) {
11856  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
11857  }
11858  arg9 = (PLFLT)(val9);
11859  ecode10 = SWIG_AsVal_double(args(7), &val10);
11860  if (!SWIG_IsOK(ecode10)) {
11861  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
11862  }
11863  arg10 = (PLFLT)(val10);
11864  ecode11 = SWIG_AsVal_double(args(8), &val11);
11865  if (!SWIG_IsOK(ecode11)) {
11866  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
11867  }
11868  arg11 = (PLFLT)(val11);
11869  {
11870  if ( _n_dims( args(9) ) > 1 )
11871  {
11872  error( "argument must be a scalar or vector" ); SWIG_fail;
11873  }
11874  if ( _dim( args(9), 0 ) != Xlen )
11875  {
11876  error( "argument vectors must be same length" ); SWIG_fail;
11877  }
11878  temp12 = args(9).matrix_value();
11879  arg12 = &temp12( 0, 0 );
11880  }
11881  {
11882  if ( _n_dims( args(10) ) > 1 )
11883  {
11884  error( "argument must be a scalar or vector" ); SWIG_fail;
11885  }
11886  if ( _dim( args(10), 0 ) != Ylen )
11887  {
11888  error( "argument vectors must be same length" ); SWIG_fail;
11889  }
11890  temp13 = args(10).matrix_value();
11891  arg13 = &temp13( 0, 0 );
11892  }
11893  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
11894  _outv = octave_value();
11895  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11896  {
11897 
11898  }
11899  {
11900 
11901  }
11902  {
11903 
11904  }
11905  return _out;
11906 fail:
11907  {
11908 
11909  }
11910  {
11911 
11912  }
11913  {
11914 
11915  }
11916  return octave_value_list();
11917 }
11918 
11919 
11920 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
11921  PLFLT *arg1 = (PLFLT *) 0 ;
11922  PLINT arg2 ;
11923  PLINT arg3 ;
11924  PLFLT arg4 ;
11925  PLFLT arg5 ;
11926  PLFLT arg6 ;
11927  PLFLT arg7 ;
11928  PLFLT arg8 ;
11929  PLFLT arg9 ;
11930  PLFLT arg10 ;
11931  PLFLT arg11 ;
11932  PLFLT *arg12 = (PLFLT *) 0 ;
11933  PLFLT *arg13 = (PLFLT *) 0 ;
11934  Matrix temp1 ;
11935  double val4 ;
11936  int ecode4 = 0 ;
11937  double val5 ;
11938  int ecode5 = 0 ;
11939  double val6 ;
11940  int ecode6 = 0 ;
11941  double val7 ;
11942  int ecode7 = 0 ;
11943  double val8 ;
11944  int ecode8 = 0 ;
11945  double val9 ;
11946  int ecode9 = 0 ;
11947  double val10 ;
11948  int ecode10 = 0 ;
11949  double val11 ;
11950  int ecode11 = 0 ;
11951  Matrix temp12 ;
11952  Matrix temp13 ;
11953  octave_value_list _out;
11954  octave_value_list *_outp=&_out;
11955  octave_value _outv;
11956 
11957  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
11958  SWIG_fail;
11959  }
11960  {
11961  if ( _n_dims( args(0) ) > 2 )
11962  {
11963  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11964  }
11965  temp1 = args(0).matrix_value();
11966  arg1 = &temp1( 0, 0 );
11967  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11968  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11969  }
11970  ecode4 = SWIG_AsVal_double(args(1), &val4);
11971  if (!SWIG_IsOK(ecode4)) {
11972  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
11973  }
11974  arg4 = (PLFLT)(val4);
11975  ecode5 = SWIG_AsVal_double(args(2), &val5);
11976  if (!SWIG_IsOK(ecode5)) {
11977  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
11978  }
11979  arg5 = (PLFLT)(val5);
11980  ecode6 = SWIG_AsVal_double(args(3), &val6);
11981  if (!SWIG_IsOK(ecode6)) {
11982  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
11983  }
11984  arg6 = (PLFLT)(val6);
11985  ecode7 = SWIG_AsVal_double(args(4), &val7);
11986  if (!SWIG_IsOK(ecode7)) {
11987  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
11988  }
11989  arg7 = (PLFLT)(val7);
11990  ecode8 = SWIG_AsVal_double(args(5), &val8);
11991  if (!SWIG_IsOK(ecode8)) {
11992  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
11993  }
11994  arg8 = (PLFLT)(val8);
11995  ecode9 = SWIG_AsVal_double(args(6), &val9);
11996  if (!SWIG_IsOK(ecode9)) {
11997  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
11998  }
11999  arg9 = (PLFLT)(val9);
12000  ecode10 = SWIG_AsVal_double(args(7), &val10);
12001  if (!SWIG_IsOK(ecode10)) {
12002  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
12003  }
12004  arg10 = (PLFLT)(val10);
12005  ecode11 = SWIG_AsVal_double(args(8), &val11);
12006  if (!SWIG_IsOK(ecode11)) {
12007  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
12008  }
12009  arg11 = (PLFLT)(val11);
12010  {
12011  if ( _n_dims( args(9) ) > 2 )
12012  {
12013  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12014  }
12015  temp12 = args(9).matrix_value();
12016  arg12 = &temp12( 0, 0 );
12017  Xlen = (PLINT) ( _dim( args(9), 0 ) );
12018  Ylen = (PLINT) ( _dim( args(9), 1 ) );
12019  }
12020  {
12021  if ( _n_dims( args(10) ) > 2 )
12022  {
12023  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12024  }
12025  temp13 = args(10).matrix_value();
12026  arg13 = &temp13( 0, 0 );
12027  Xlen = (PLINT) ( _dim( args(10), 0 ) );
12028  Ylen = (PLINT) ( _dim( args(10), 1 ) );
12029  }
12030  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
12031  _outv = octave_value();
12032  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12033  {
12034 
12035  }
12036  {
12037 
12038  }
12039  {
12040 
12041  }
12042  return _out;
12043 fail:
12044  {
12045 
12046  }
12047  {
12048 
12049  }
12050  {
12051 
12052  }
12053  return octave_value_list();
12054 }
12055 
12056 
12058  PLFLT *arg1 = (PLFLT *) 0 ;
12059  PLFLT *arg2 = (PLFLT *) 0 ;
12060  PLINT arg3 ;
12061  PLINT arg4 ;
12062  PLFLT arg5 ;
12063  PLFLT arg6 ;
12064  PLFLT arg7 ;
12065  PLFLT arg8 ;
12066  PLINT arg9 ;
12067  PLINT arg10 ;
12068  PLINT arg11 ;
12069  PLFLT arg12 ;
12070  PLFLT arg13 ;
12071  PLINT arg14 ;
12072  PLFLT arg15 ;
12073  PLINT arg16 ;
12074  PLINT *arg17 = (PLINT *) 0 ;
12075  char **arg18 = (char **) 0 ;
12076  PLINT arg19 ;
12077  char **arg20 = (char **) 0 ;
12078  PLFLT *arg21 = (PLFLT *) 0 ;
12079  PLINT *arg22 = (PLINT *) 0 ;
12080  PLINT *arg23 = (PLINT *) 0 ;
12081  PLFLT *arg24 = (PLFLT *) 0 ;
12082  PLFLT temp1 ;
12083  int res1 = SWIG_TMPOBJ ;
12084  PLFLT temp2 ;
12085  int res2 = SWIG_TMPOBJ ;
12086  int val3 ;
12087  int ecode3 = 0 ;
12088  int val4 ;
12089  int ecode4 = 0 ;
12090  double val5 ;
12091  int ecode5 = 0 ;
12092  double val6 ;
12093  int ecode6 = 0 ;
12094  double val7 ;
12095  int ecode7 = 0 ;
12096  double val8 ;
12097  int ecode8 = 0 ;
12098  int val9 ;
12099  int ecode9 = 0 ;
12100  int val10 ;
12101  int ecode10 = 0 ;
12102  int val11 ;
12103  int ecode11 = 0 ;
12104  double val12 ;
12105  int ecode12 = 0 ;
12106  double val13 ;
12107  int ecode13 = 0 ;
12108  int val14 ;
12109  int ecode14 = 0 ;
12110  double val15 ;
12111  int ecode15 = 0 ;
12112  Matrix temp16 ;
12113  Matrix temp21 ;
12114  Matrix temp22 ;
12115  Matrix temp23 ;
12116  Matrix temp24 ;
12117  octave_value_list _out;
12118  octave_value_list *_outp=&_out;
12119  octave_value _outv;
12120 
12121  arg1 = &temp1;
12122  arg2 = &temp2;
12123  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
12124  SWIG_fail;
12125  }
12126  ecode3 = SWIG_AsVal_int(args(0), &val3);
12127  if (!SWIG_IsOK(ecode3)) {
12128  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
12129  }
12130  arg3 = (PLINT)(val3);
12131  ecode4 = SWIG_AsVal_int(args(1), &val4);
12132  if (!SWIG_IsOK(ecode4)) {
12133  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
12134  }
12135  arg4 = (PLINT)(val4);
12136  ecode5 = SWIG_AsVal_double(args(2), &val5);
12137  if (!SWIG_IsOK(ecode5)) {
12138  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
12139  }
12140  arg5 = (PLFLT)(val5);
12141  ecode6 = SWIG_AsVal_double(args(3), &val6);
12142  if (!SWIG_IsOK(ecode6)) {
12143  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
12144  }
12145  arg6 = (PLFLT)(val6);
12146  ecode7 = SWIG_AsVal_double(args(4), &val7);
12147  if (!SWIG_IsOK(ecode7)) {
12148  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
12149  }
12150  arg7 = (PLFLT)(val7);
12151  ecode8 = SWIG_AsVal_double(args(5), &val8);
12152  if (!SWIG_IsOK(ecode8)) {
12153  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
12154  }
12155  arg8 = (PLFLT)(val8);
12156  ecode9 = SWIG_AsVal_int(args(6), &val9);
12157  if (!SWIG_IsOK(ecode9)) {
12158  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
12159  }
12160  arg9 = (PLINT)(val9);
12161  ecode10 = SWIG_AsVal_int(args(7), &val10);
12162  if (!SWIG_IsOK(ecode10)) {
12163  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
12164  }
12165  arg10 = (PLINT)(val10);
12166  ecode11 = SWIG_AsVal_int(args(8), &val11);
12167  if (!SWIG_IsOK(ecode11)) {
12168  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
12169  }
12170  arg11 = (PLINT)(val11);
12171  ecode12 = SWIG_AsVal_double(args(9), &val12);
12172  if (!SWIG_IsOK(ecode12)) {
12173  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
12174  }
12175  arg12 = (PLFLT)(val12);
12176  ecode13 = SWIG_AsVal_double(args(10), &val13);
12177  if (!SWIG_IsOK(ecode13)) {
12178  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
12179  }
12180  arg13 = (PLFLT)(val13);
12181  ecode14 = SWIG_AsVal_int(args(11), &val14);
12182  if (!SWIG_IsOK(ecode14)) {
12183  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
12184  }
12185  arg14 = (PLINT)(val14);
12186  ecode15 = SWIG_AsVal_double(args(12), &val15);
12187  if (!SWIG_IsOK(ecode15)) {
12188  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
12189  }
12190  arg15 = (PLFLT)(val15);
12191  {
12192  if ( _n_dims( args(13) ) > 1 )
12193  {
12194  error( "argument must be a scalar or vector" ); SWIG_fail;
12195  }
12196  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
12197  arg17 = new PLINT[Alen];
12198  temp16 = args(13).matrix_value();
12199  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
12200  }
12201  {
12202  charMatrix temp_matrix;
12203  Cell temp_cell;
12204  char *tmp_cstring;
12205  std::string str;
12206  size_t max_length, non_blank_length;
12207  int i, ifcell;
12208  if ( _n_dims( args(14) ) > 2 )
12209  {
12210  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
12211  }
12212  if ( !args(14).is_empty() )
12213  {
12214  if ( _dim( args(14), 0 ) != Alen )
12215  {
12216  error( "first dimension must be same length as previous vector" ); SWIG_fail;
12217  }
12218  arg18 = new char*[Alen];
12219  ifcell = args(14).is_cell();
12220  if ( ifcell )
12221  {
12222  temp_cell = args(14).cell_value();
12223  }
12224  else
12225  {
12226  temp_matrix = args(14).char_matrix_value();
12227  // Allow one extra space for null termination.
12228  max_length = _dim( args(14), 1 ) + 1;
12229  }
12230 
12231  for ( i = 0; i < Alen; i++ )
12232  {
12233  // Must copy string to "permanent" location because the string
12234  // location corresponding to tmp_cstring gets
12235  // overwritten for each iteration of loop.
12236  if ( ifcell )
12237  {
12238  if ( temp_cell.elem( i ).is_string() )
12239  {
12240  str = temp_cell.elem( i ).string_value();
12241  // leave room for null termination.
12242  max_length = str.size() + 1;
12243  tmp_cstring = (char *) str.c_str();
12244  }
12245  else
12246  {
12247  // Use null string if user attempts to pass a cell array
12248  // with a non-string element (likely an empty element
12249  // since that should be allowed by the PLplot interface
12250  // if that element is going to be unused).
12251  // leave room for null termination.
12252  max_length = 1;
12253  tmp_cstring = (char *) "";
12254  }
12255  }
12256  else
12257  {
12258  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12259  }
12260  arg18[i] = new char[max_length];
12261  strncpy( arg18[i], tmp_cstring, max_length - 1 );
12262  arg18[i][max_length - 1] = '\0';
12263  // All the trailing blank crapola should not be needed for
12264  // string cell arrays.
12265  if ( !ifcell )
12266  {
12267  // remove trailing-blank padding that is used by the
12268  // charMatrix class to insure all strings in a given
12269  // charMatrix instance have the same length.
12270  // This transformation also removes legitimate trailing
12271  // blanks but there is nothing we can do about that
12272  // for the charMatrix class.
12273 
12274  // Look for trailing nulls first (just in case, although that
12275  // shouldn't happen if charMatrix implemented as documented)
12276  // before looking for trailing blanks.
12277  non_blank_length = max_length - 2;
12278  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
12279  {
12280  non_blank_length--;
12281  }
12282  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
12283  {
12284  non_blank_length--;
12285  }
12286  arg18[i][non_blank_length + 1] = '\0';
12287  }
12288  }
12289  }
12290  else
12291  {
12292  arg18 = NULL;
12293  }
12294  }
12295  {
12296  charMatrix temp_matrix;
12297  Cell temp_cell;
12298  char *tmp_cstring;
12299  std::string str;
12300  size_t max_length, non_blank_length;
12301  int i, ifcell;
12302  if ( _n_dims( args(15) ) > 2 )
12303  {
12304  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
12305  }
12306  if ( !args(15).is_empty() )
12307  {
12308  Alen = _dim( args(15), 0 );
12309  arg19 = Alen;
12310  arg20 = new char*[Alen];
12311  ifcell = args(15).is_cell();
12312  if ( ifcell )
12313  {
12314  temp_cell = args(15).cell_value();
12315  }
12316  else
12317  {
12318  temp_matrix = args(15).char_matrix_value();
12319  // Allow one extra space for null termination.
12320  max_length = _dim( args(15), 1 ) + 1;
12321  }
12322 
12323  for ( i = 0; i < Alen; i++ )
12324  {
12325  // Must copy string to "permanent" location because the string
12326  // location corresponding to tmp_cstring gets
12327  // overwritten for each iteration of loop.
12328  if ( ifcell )
12329  {
12330  if ( temp_cell.elem( i ).is_string() )
12331  {
12332  str = temp_cell.elem( i ).string_value();
12333  // leave room for null termination.
12334  max_length = str.size() + 1;
12335  tmp_cstring = (char *) str.c_str();
12336  }
12337  else
12338  {
12339  // Use null string if user attempts to pass a cell array
12340  // with a non-string element (likely an empty element
12341  // since that should be allowed by the PLplot interface
12342  // if that element is going to be unused).
12343  // leave room for null termination.
12344  max_length = 1;
12345  tmp_cstring = (char *) "";
12346  }
12347  }
12348  else
12349  {
12350  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12351  }
12352  arg20[i] = new char[max_length];
12353  strncpy( arg20[i], tmp_cstring, max_length - 1 );
12354  arg20[i][max_length - 1] = '\0';
12355  // All the trailing blank crapola should not be needed for
12356  // string cell arrays.
12357  if ( !ifcell )
12358  {
12359  // remove trailing-blank padding that is used by the
12360  // charMatrix class to insure all strings in a given
12361  // charMatrix instance have the same length.
12362  // This transformation also removes legitimate trailing
12363  // blanks but there is nothing we can do about that
12364  // for the charMatrix class.
12365 
12366  // Look for trailing nulls first (just in case, although that
12367  // shouldn't happen if charMatrix implemented as documented)
12368  // before looking for trailing blanks.
12369  non_blank_length = max_length - 2;
12370  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
12371  {
12372  non_blank_length--;
12373  }
12374  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
12375  {
12376  non_blank_length--;
12377  }
12378  arg20[i][non_blank_length + 1] = '\0';
12379  }
12380  }
12381  }
12382  else
12383  {
12384  arg19 = 0;
12385  arg20 = NULL;
12386  }
12387  }
12388  {
12389  if ( _n_dims( args(16) ) > 1 )
12390  {
12391  error( "argument must be a scalar or vector" ); SWIG_fail;
12392  }
12393  if ( _dim( args(16), 0 ) != Alen )
12394  {
12395  error( "argument vectors must be same length" ); SWIG_fail;
12396  }
12397  temp21 = args(16).matrix_value();
12398  arg21 = &temp21( 0, 0 );
12399  }
12400  {
12401  if ( _n_dims( args(17) ) > 1 )
12402  {
12403  error( "argument must be a scalar or vector" ); SWIG_fail;
12404  }
12405  if ( _dim( args(17), 0 ) != Alen )
12406  {
12407  error( "argument vectors must be same length" ); SWIG_fail;
12408  }
12409  temp22 = args(17).matrix_value();
12410  arg22 = new PLINT[Alen];
12411  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
12412  }
12413  {
12414  int i;
12415  if ( _n_dims( args(18) ) > 1 )
12416  {
12417  error( "argument must be a scalar or vector" ); SWIG_fail;
12418  }
12419  if ( _dim( args(18), 0 ) != Alen )
12420  {
12421  error( "argument vectors must be same length" ); SWIG_fail;
12422  }
12423  Xlen = Alen;
12424  temp23 = args(18).matrix_value();
12425  arg23 = new PLINT[Alen];
12426  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
12427  Ylen = -1;
12428  for ( i = 0; i < Xlen; i++ )
12429  if ( arg23[i] > Ylen )
12430  Ylen = arg23[i];
12431  }
12432  {
12433  if ( _n_dims( args(19) ) > 2 )
12434  {
12435  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12436  }
12437  if ( _dim( args(19), 0 ) != Xlen )
12438  {
12439  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12440  }
12441  if ( _dim( args(19), 1 ) != Ylen )
12442  {
12443  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12444  }
12445  temp24 = args(19).matrix_value();
12446  arg24 = &temp24( 0, 0 );
12447  }
12448  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);
12449  _outv = octave_value();
12450  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12451  if (SWIG_IsTmpObj(res1)) {
12452  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
12453  } else {
12454  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12455  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
12456  }
12457  if (SWIG_IsTmpObj(res2)) {
12458  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
12459  } else {
12460  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12461  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
12462  }
12463  {
12464  delete [] arg17;
12465  }
12466  {
12467  int i;
12468  if ( arg18 != NULL )
12469  {
12470  for ( i = 0; i < Alen; i++ )
12471  {
12472  delete[] arg18[i];
12473  }
12474  delete[] arg18;
12475  }
12476  }
12477  {
12478  int i;
12479  if ( arg20 != NULL )
12480  {
12481  for ( i = 0; i < Alen; i++ )
12482  {
12483  delete[] arg20[i];
12484  }
12485  delete[] arg20;
12486  }
12487  }
12488  {
12489 
12490  }
12491  {
12492  delete [] arg22;
12493  }
12494  {
12495  delete [] arg23;
12496  }
12497  {
12498 
12499  }
12500  return _out;
12501 fail:
12502  {
12503  delete [] arg17;
12504  }
12505  {
12506  int i;
12507  if ( arg18 != NULL )
12508  {
12509  for ( i = 0; i < Alen; i++ )
12510  {
12511  delete[] arg18[i];
12512  }
12513  delete[] arg18;
12514  }
12515  }
12516  {
12517  int i;
12518  if ( arg20 != NULL )
12519  {
12520  for ( i = 0; i < Alen; i++ )
12521  {
12522  delete[] arg20[i];
12523  }
12524  delete[] arg20;
12525  }
12526  }
12527  {
12528 
12529  }
12530  {
12531  delete [] arg22;
12532  }
12533  {
12534  delete [] arg23;
12535  }
12536  {
12537 
12538  }
12539  return octave_value_list();
12540 }
12541 
12542 
12543 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
12544  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12545  int arg2 ;
12546  void *argp1 = 0 ;
12547  int res1 = 0 ;
12548  int val2 ;
12549  int ecode2 = 0 ;
12550  octave_value_list _out;
12551  octave_value_list *_outp=&_out;
12552  octave_value _outv;
12553 
12554  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
12555  SWIG_fail;
12556  }
12557  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12558  if (!SWIG_IsOK(res1)) {
12559  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12560  }
12561  arg1 = (PLGraphicsIn *)(argp1);
12562  ecode2 = SWIG_AsVal_int(args(1), &val2);
12563  if (!SWIG_IsOK(ecode2)) {
12564  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
12565  }
12566  arg2 = (int)(val2);
12567  if (arg1) (arg1)->type = arg2;
12568  _outv = octave_value();
12569  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12570  return _out;
12571 fail:
12572  return octave_value_list();
12573 }
12574 
12575 
12576 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
12577  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12578  void *argp1 = 0 ;
12579  int res1 = 0 ;
12580  octave_value_list _out;
12581  octave_value_list *_outp=&_out;
12582  octave_value _outv;
12583  int result;
12584 
12585  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
12586  SWIG_fail;
12587  }
12588  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12589  if (!SWIG_IsOK(res1)) {
12590  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12591  }
12592  arg1 = (PLGraphicsIn *)(argp1);
12593  result = (int) ((arg1)->type);
12594  _outv = SWIG_From_int((int)(result));
12595  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12596  return _out;
12597 fail:
12598  return octave_value_list();
12599 }
12600 
12601 
12602 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
12603  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12604  unsigned int arg2 ;
12605  void *argp1 = 0 ;
12606  int res1 = 0 ;
12607  unsigned int val2 ;
12608  int ecode2 = 0 ;
12609  octave_value_list _out;
12610  octave_value_list *_outp=&_out;
12611  octave_value _outv;
12612 
12613  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
12614  SWIG_fail;
12615  }
12616  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12617  if (!SWIG_IsOK(res1)) {
12618  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12619  }
12620  arg1 = (PLGraphicsIn *)(argp1);
12621  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12622  if (!SWIG_IsOK(ecode2)) {
12623  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
12624  }
12625  arg2 = (unsigned int)(val2);
12626  if (arg1) (arg1)->state = arg2;
12627  _outv = octave_value();
12628  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12629  return _out;
12630 fail:
12631  return octave_value_list();
12632 }
12633 
12634 
12635 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
12636  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12637  void *argp1 = 0 ;
12638  int res1 = 0 ;
12639  octave_value_list _out;
12640  octave_value_list *_outp=&_out;
12641  octave_value _outv;
12642  unsigned int result;
12643 
12644  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
12645  SWIG_fail;
12646  }
12647  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12648  if (!SWIG_IsOK(res1)) {
12649  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12650  }
12651  arg1 = (PLGraphicsIn *)(argp1);
12652  result = (unsigned int) ((arg1)->state);
12653  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12654  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12655  return _out;
12656 fail:
12657  return octave_value_list();
12658 }
12659 
12660 
12661 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
12662  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12663  unsigned int arg2 ;
12664  void *argp1 = 0 ;
12665  int res1 = 0 ;
12666  unsigned int val2 ;
12667  int ecode2 = 0 ;
12668  octave_value_list _out;
12669  octave_value_list *_outp=&_out;
12670  octave_value _outv;
12671 
12672  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
12673  SWIG_fail;
12674  }
12675  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12676  if (!SWIG_IsOK(res1)) {
12677  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12678  }
12679  arg1 = (PLGraphicsIn *)(argp1);
12680  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12681  if (!SWIG_IsOK(ecode2)) {
12682  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
12683  }
12684  arg2 = (unsigned int)(val2);
12685  if (arg1) (arg1)->keysym = arg2;
12686  _outv = octave_value();
12687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12688  return _out;
12689 fail:
12690  return octave_value_list();
12691 }
12692 
12693 
12694 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
12695  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12696  void *argp1 = 0 ;
12697  int res1 = 0 ;
12698  octave_value_list _out;
12699  octave_value_list *_outp=&_out;
12700  octave_value _outv;
12701  unsigned int result;
12702 
12703  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
12704  SWIG_fail;
12705  }
12706  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12707  if (!SWIG_IsOK(res1)) {
12708  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12709  }
12710  arg1 = (PLGraphicsIn *)(argp1);
12711  result = (unsigned int) ((arg1)->keysym);
12712  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12713  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12714  return _out;
12715 fail:
12716  return octave_value_list();
12717 }
12718 
12719 
12720 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
12721  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12722  unsigned int arg2 ;
12723  void *argp1 = 0 ;
12724  int res1 = 0 ;
12725  unsigned int val2 ;
12726  int ecode2 = 0 ;
12727  octave_value_list _out;
12728  octave_value_list *_outp=&_out;
12729  octave_value _outv;
12730 
12731  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
12732  SWIG_fail;
12733  }
12734  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12735  if (!SWIG_IsOK(res1)) {
12736  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12737  }
12738  arg1 = (PLGraphicsIn *)(argp1);
12739  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12740  if (!SWIG_IsOK(ecode2)) {
12741  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
12742  }
12743  arg2 = (unsigned int)(val2);
12744  if (arg1) (arg1)->button = arg2;
12745  _outv = octave_value();
12746  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12747  return _out;
12748 fail:
12749  return octave_value_list();
12750 }
12751 
12752 
12753 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
12754  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12755  void *argp1 = 0 ;
12756  int res1 = 0 ;
12757  octave_value_list _out;
12758  octave_value_list *_outp=&_out;
12759  octave_value _outv;
12760  unsigned int result;
12761 
12762  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
12763  SWIG_fail;
12764  }
12765  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12766  if (!SWIG_IsOK(res1)) {
12767  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12768  }
12769  arg1 = (PLGraphicsIn *)(argp1);
12770  result = (unsigned int) ((arg1)->button);
12771  _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12772  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12773  return _out;
12774 fail:
12775  return octave_value_list();
12776 }
12777 
12778 
12779 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
12780  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12781  PLINT arg2 ;
12782  void *argp1 = 0 ;
12783  int res1 = 0 ;
12784  int val2 ;
12785  int ecode2 = 0 ;
12786  octave_value_list _out;
12787  octave_value_list *_outp=&_out;
12788  octave_value _outv;
12789 
12790  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
12791  SWIG_fail;
12792  }
12793  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12794  if (!SWIG_IsOK(res1)) {
12795  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12796  }
12797  arg1 = (PLGraphicsIn *)(argp1);
12798  ecode2 = SWIG_AsVal_int(args(1), &val2);
12799  if (!SWIG_IsOK(ecode2)) {
12800  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
12801  }
12802  arg2 = (PLINT)(val2);
12803  if (arg1) (arg1)->subwindow = arg2;
12804  _outv = octave_value();
12805  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12806  return _out;
12807 fail:
12808  return octave_value_list();
12809 }
12810 
12811 
12812 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
12813  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12814  void *argp1 = 0 ;
12815  int res1 = 0 ;
12816  octave_value_list _out;
12817  octave_value_list *_outp=&_out;
12818  octave_value _outv;
12819  PLINT result;
12820 
12821  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
12822  SWIG_fail;
12823  }
12824  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12825  if (!SWIG_IsOK(res1)) {
12826  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12827  }
12828  arg1 = (PLGraphicsIn *)(argp1);
12829  result = (PLINT) ((arg1)->subwindow);
12830  _outv = SWIG_From_int((int)(result));
12831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12832  return _out;
12833 fail:
12834  return octave_value_list();
12835 }
12836 
12837 
12838 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
12839  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12840  char *arg2 ;
12841  void *argp1 = 0 ;
12842  int res1 = 0 ;
12843  char temp2[16] ;
12844  int res2 ;
12845  octave_value_list _out;
12846  octave_value_list *_outp=&_out;
12847  octave_value _outv;
12848 
12849  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
12850  SWIG_fail;
12851  }
12852  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12853  if (!SWIG_IsOK(res1)) {
12854  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12855  }
12856  arg1 = (PLGraphicsIn *)(argp1);
12857  res2 = SWIG_AsCharArray(args(1), temp2, 16);
12858  if (!SWIG_IsOK(res2)) {
12859  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
12860  }
12861  arg2 = (char *)(temp2);
12862  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
12863  else memset(arg1->string,0,16*sizeof(char));
12864  _outv = octave_value();
12865  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12866  return _out;
12867 fail:
12868  return octave_value_list();
12869 }
12870 
12871 
12872 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
12873  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12874  void *argp1 = 0 ;
12875  int res1 = 0 ;
12876  octave_value_list _out;
12877  octave_value_list *_outp=&_out;
12878  octave_value _outv;
12879  char *result = 0 ;
12880 
12881  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
12882  SWIG_fail;
12883  }
12884  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12885  if (!SWIG_IsOK(res1)) {
12886  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12887  }
12888  arg1 = (PLGraphicsIn *)(argp1);
12889  result = (char *)(char *) ((arg1)->string);
12890  {
12891  size_t size = 16;
12892 
12893  while (size && (result[size - 1] == '\0')) --size;
12894 
12895  _outv = SWIG_FromCharPtrAndSize(result, size);
12896  }
12897  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12898  return _out;
12899 fail:
12900  return octave_value_list();
12901 }
12902 
12903 
12904 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
12905  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12906  int arg2 ;
12907  void *argp1 = 0 ;
12908  int res1 = 0 ;
12909  int val2 ;
12910  int ecode2 = 0 ;
12911  octave_value_list _out;
12912  octave_value_list *_outp=&_out;
12913  octave_value _outv;
12914 
12915  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
12916  SWIG_fail;
12917  }
12918  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12919  if (!SWIG_IsOK(res1)) {
12920  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12921  }
12922  arg1 = (PLGraphicsIn *)(argp1);
12923  ecode2 = SWIG_AsVal_int(args(1), &val2);
12924  if (!SWIG_IsOK(ecode2)) {
12925  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
12926  }
12927  arg2 = (int)(val2);
12928  if (arg1) (arg1)->pX = arg2;
12929  _outv = octave_value();
12930  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12931  return _out;
12932 fail:
12933  return octave_value_list();
12934 }
12935 
12936 
12937 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
12938  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12939  void *argp1 = 0 ;
12940  int res1 = 0 ;
12941  octave_value_list _out;
12942  octave_value_list *_outp=&_out;
12943  octave_value _outv;
12944  int result;
12945 
12946  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
12947  SWIG_fail;
12948  }
12949  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12950  if (!SWIG_IsOK(res1)) {
12951  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12952  }
12953  arg1 = (PLGraphicsIn *)(argp1);
12954  result = (int) ((arg1)->pX);
12955  _outv = SWIG_From_int((int)(result));
12956  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12957  return _out;
12958 fail:
12959  return octave_value_list();
12960 }
12961 
12962 
12963 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
12964  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12965  int arg2 ;
12966  void *argp1 = 0 ;
12967  int res1 = 0 ;
12968  int val2 ;
12969  int ecode2 = 0 ;
12970  octave_value_list _out;
12971  octave_value_list *_outp=&_out;
12972  octave_value _outv;
12973 
12974  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
12975  SWIG_fail;
12976  }
12977  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12978  if (!SWIG_IsOK(res1)) {
12979  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12980  }
12981  arg1 = (PLGraphicsIn *)(argp1);
12982  ecode2 = SWIG_AsVal_int(args(1), &val2);
12983  if (!SWIG_IsOK(ecode2)) {
12984  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
12985  }
12986  arg2 = (int)(val2);
12987  if (arg1) (arg1)->pY = arg2;
12988  _outv = octave_value();
12989  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12990  return _out;
12991 fail:
12992  return octave_value_list();
12993 }
12994 
12995 
12996 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
12997  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12998  void *argp1 = 0 ;
12999  int res1 = 0 ;
13000  octave_value_list _out;
13001  octave_value_list *_outp=&_out;
13002  octave_value _outv;
13003  int result;
13004 
13005  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
13006  SWIG_fail;
13007  }
13008  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13009  if (!SWIG_IsOK(res1)) {
13010  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13011  }
13012  arg1 = (PLGraphicsIn *)(argp1);
13013  result = (int) ((arg1)->pY);
13014  _outv = SWIG_From_int((int)(result));
13015  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13016  return _out;
13017 fail:
13018  return octave_value_list();
13019 }
13020 
13021 
13022 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
13023  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13024  PLFLT arg2 ;
13025  void *argp1 = 0 ;
13026  int res1 = 0 ;
13027  double val2 ;
13028  int ecode2 = 0 ;
13029  octave_value_list _out;
13030  octave_value_list *_outp=&_out;
13031  octave_value _outv;
13032 
13033  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
13034  SWIG_fail;
13035  }
13036  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13037  if (!SWIG_IsOK(res1)) {
13038  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13039  }
13040  arg1 = (PLGraphicsIn *)(argp1);
13041  ecode2 = SWIG_AsVal_double(args(1), &val2);
13042  if (!SWIG_IsOK(ecode2)) {
13043  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
13044  }
13045  arg2 = (PLFLT)(val2);
13046  if (arg1) (arg1)->dX = arg2;
13047  _outv = octave_value();
13048  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13049  return _out;
13050 fail:
13051  return octave_value_list();
13052 }
13053 
13054 
13055 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
13056  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13057  void *argp1 = 0 ;
13058  int res1 = 0 ;
13059  octave_value_list _out;
13060  octave_value_list *_outp=&_out;
13061  octave_value _outv;
13062  PLFLT result;
13063 
13064  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
13065  SWIG_fail;
13066  }
13067  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13068  if (!SWIG_IsOK(res1)) {
13069  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13070  }
13071  arg1 = (PLGraphicsIn *)(argp1);
13072  result = (PLFLT) ((arg1)->dX);
13073  _outv = SWIG_From_double((double)(result));
13074  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13075  return _out;
13076 fail:
13077  return octave_value_list();
13078 }
13079 
13080 
13081 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
13082  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13083  PLFLT arg2 ;
13084  void *argp1 = 0 ;
13085  int res1 = 0 ;
13086  double val2 ;
13087  int ecode2 = 0 ;
13088  octave_value_list _out;
13089  octave_value_list *_outp=&_out;
13090  octave_value _outv;
13091 
13092  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
13093  SWIG_fail;
13094  }
13095  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13096  if (!SWIG_IsOK(res1)) {
13097  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13098  }
13099  arg1 = (PLGraphicsIn *)(argp1);
13100  ecode2 = SWIG_AsVal_double(args(1), &val2);
13101  if (!SWIG_IsOK(ecode2)) {
13102  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
13103  }
13104  arg2 = (PLFLT)(val2);
13105  if (arg1) (arg1)->dY = arg2;
13106  _outv = octave_value();
13107  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13108  return _out;
13109 fail:
13110  return octave_value_list();
13111 }
13112 
13113 
13114 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
13115  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13116  void *argp1 = 0 ;
13117  int res1 = 0 ;
13118  octave_value_list _out;
13119  octave_value_list *_outp=&_out;
13120  octave_value _outv;
13121  PLFLT result;
13122 
13123  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
13124  SWIG_fail;
13125  }
13126  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13127  if (!SWIG_IsOK(res1)) {
13128  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13129  }
13130  arg1 = (PLGraphicsIn *)(argp1);
13131  result = (PLFLT) ((arg1)->dY);
13132  _outv = SWIG_From_double((double)(result));
13133  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13134  return _out;
13135 fail:
13136  return octave_value_list();
13137 }
13138 
13139 
13140 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
13141  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13142  PLFLT arg2 ;
13143  void *argp1 = 0 ;
13144  int res1 = 0 ;
13145  double val2 ;
13146  int ecode2 = 0 ;
13147  octave_value_list _out;
13148  octave_value_list *_outp=&_out;
13149  octave_value _outv;
13150 
13151  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
13152  SWIG_fail;
13153  }
13154  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13155  if (!SWIG_IsOK(res1)) {
13156  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13157  }
13158  arg1 = (PLGraphicsIn *)(argp1);
13159  ecode2 = SWIG_AsVal_double(args(1), &val2);
13160  if (!SWIG_IsOK(ecode2)) {
13161  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
13162  }
13163  arg2 = (PLFLT)(val2);
13164  if (arg1) (arg1)->wX = arg2;
13165  _outv = octave_value();
13166  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13167  return _out;
13168 fail:
13169  return octave_value_list();
13170 }
13171 
13172 
13173 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
13174  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13175  void *argp1 = 0 ;
13176  int res1 = 0 ;
13177  octave_value_list _out;
13178  octave_value_list *_outp=&_out;
13179  octave_value _outv;
13180  PLFLT result;
13181 
13182  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
13183  SWIG_fail;
13184  }
13185  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13186  if (!SWIG_IsOK(res1)) {
13187  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13188  }
13189  arg1 = (PLGraphicsIn *)(argp1);
13190  result = (PLFLT) ((arg1)->wX);
13191  _outv = SWIG_From_double((double)(result));
13192  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13193  return _out;
13194 fail:
13195  return octave_value_list();
13196 }
13197 
13198 
13199 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
13200  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13201  PLFLT arg2 ;
13202  void *argp1 = 0 ;
13203  int res1 = 0 ;
13204  double val2 ;
13205  int ecode2 = 0 ;
13206  octave_value_list _out;
13207  octave_value_list *_outp=&_out;
13208  octave_value _outv;
13209 
13210  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
13211  SWIG_fail;
13212  }
13213  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13214  if (!SWIG_IsOK(res1)) {
13215  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13216  }
13217  arg1 = (PLGraphicsIn *)(argp1);
13218  ecode2 = SWIG_AsVal_double(args(1), &val2);
13219  if (!SWIG_IsOK(ecode2)) {
13220  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
13221  }
13222  arg2 = (PLFLT)(val2);
13223  if (arg1) (arg1)->wY = arg2;
13224  _outv = octave_value();
13225  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13226  return _out;
13227 fail:
13228  return octave_value_list();
13229 }
13230 
13231 
13232 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
13233  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13234  void *argp1 = 0 ;
13235  int res1 = 0 ;
13236  octave_value_list _out;
13237  octave_value_list *_outp=&_out;
13238  octave_value _outv;
13239  PLFLT result;
13240 
13241  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
13242  SWIG_fail;
13243  }
13244  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
13245  if (!SWIG_IsOK(res1)) {
13246  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13247  }
13248  arg1 = (PLGraphicsIn *)(argp1);
13249  result = (PLFLT) ((arg1)->wY);
13250  _outv = SWIG_From_double((double)(result));
13251  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13252  return _out;
13253 fail:
13254  return octave_value_list();
13255 }
13256 
13257 
13258 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
13259  octave_value_list _out;
13260  octave_value_list *_outp=&_out;
13261  octave_value _outv;
13262  PLGraphicsIn *result = 0 ;
13263 
13264  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
13265  SWIG_fail;
13266  }
13267  result = (PLGraphicsIn *)new PLGraphicsIn();
13269  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13270  return _out;
13271 fail:
13272  return octave_value_list();
13273 }
13274 
13275 
13276 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
13277  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
13278  void *argp1 = 0 ;
13279  int res1 = 0 ;
13280  octave_value_list _out;
13281  octave_value_list *_outp=&_out;
13282  octave_value _outv;
13283 
13284  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
13285  SWIG_fail;
13286  }
13287  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
13288  if (!SWIG_IsOK(res1)) {
13289  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
13290  }
13291  arg1 = (PLGraphicsIn *)(argp1);
13292  delete arg1;
13293  _outv = octave_value();
13294  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13295  return _out;
13296 fail:
13297  return octave_value_list();
13298 }
13299 
13300 
13314 {0,0,0,0}
13315 };
13316 static const char *swig_PLGraphicsIn_base_names[] = {0};
13319 
13320 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
13321  PLINT arg1 ;
13322  PLINT arg2 ;
13323  int val1 ;
13324  int ecode1 = 0 ;
13325  int val2 ;
13326  int ecode2 = 0 ;
13327  octave_value_list _out;
13328  octave_value_list *_outp=&_out;
13329  octave_value _outv;
13330 
13331  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
13332  SWIG_fail;
13333  }
13334  ecode1 = SWIG_AsVal_int(args(0), &val1);
13335  if (!SWIG_IsOK(ecode1)) {
13336  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
13337  }
13338  arg1 = (PLINT)(val1);
13339  ecode2 = SWIG_AsVal_int(args(1), &val2);
13340  if (!SWIG_IsOK(ecode2)) {
13341  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
13342  }
13343  arg2 = (PLINT)(val2);
13344  pl_setcontlabelformat(arg1,arg2);
13345  _outv = octave_value();
13346  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13347  return _out;
13348 fail:
13349  return octave_value_list();
13350 }
13351 
13352 
13353 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
13354  PLFLT arg1 ;
13355  PLFLT arg2 ;
13356  PLFLT arg3 ;
13357  PLINT arg4 ;
13358  double val1 ;
13359  int ecode1 = 0 ;
13360  double val2 ;
13361  int ecode2 = 0 ;
13362  double val3 ;
13363  int ecode3 = 0 ;
13364  int val4 ;
13365  int ecode4 = 0 ;
13366  octave_value_list _out;
13367  octave_value_list *_outp=&_out;
13368  octave_value _outv;
13369 
13370  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
13371  SWIG_fail;
13372  }
13373  ecode1 = SWIG_AsVal_double(args(0), &val1);
13374  if (!SWIG_IsOK(ecode1)) {
13375  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
13376  }
13377  arg1 = (PLFLT)(val1);
13378  ecode2 = SWIG_AsVal_double(args(1), &val2);
13379  if (!SWIG_IsOK(ecode2)) {
13380  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
13381  }
13382  arg2 = (PLFLT)(val2);
13383  ecode3 = SWIG_AsVal_double(args(2), &val3);
13384  if (!SWIG_IsOK(ecode3)) {
13385  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
13386  }
13387  arg3 = (PLFLT)(val3);
13388  ecode4 = SWIG_AsVal_int(args(3), &val4);
13389  if (!SWIG_IsOK(ecode4)) {
13390  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
13391  }
13392  arg4 = (PLINT)(val4);
13393  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
13394  _outv = octave_value();
13395  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13396  return _out;
13397 fail:
13398  return octave_value_list();
13399 }
13400 
13401 
13402 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
13403  PLINT arg1 ;
13404  int val1 ;
13405  int ecode1 = 0 ;
13406  octave_value_list _out;
13407  octave_value_list *_outp=&_out;
13408  octave_value _outv;
13409 
13410  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
13411  SWIG_fail;
13412  }
13413  ecode1 = SWIG_AsVal_int(args(0), &val1);
13414  if (!SWIG_IsOK(ecode1)) {
13415  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
13416  }
13417  arg1 = (PLINT)(val1);
13418  pladv(arg1);
13419  _outv = octave_value();
13420  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13421  return _out;
13422 fail:
13423  return octave_value_list();
13424 }
13425 
13426 
13427 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
13428  PLFLT arg1 ;
13429  PLFLT arg2 ;
13430  PLFLT arg3 ;
13431  PLFLT arg4 ;
13432  PLFLT arg5 ;
13433  PLFLT arg6 ;
13434  PLFLT arg7 ;
13435  PLBOOL arg8 ;
13436  double val1 ;
13437  int ecode1 = 0 ;
13438  double val2 ;
13439  int ecode2 = 0 ;
13440  double val3 ;
13441  int ecode3 = 0 ;
13442  double val4 ;
13443  int ecode4 = 0 ;
13444  double val5 ;
13445  int ecode5 = 0 ;
13446  double val6 ;
13447  int ecode6 = 0 ;
13448  double val7 ;
13449  int ecode7 = 0 ;
13450  int val8 ;
13451  int ecode8 = 0 ;
13452  octave_value_list _out;
13453  octave_value_list *_outp=&_out;
13454  octave_value _outv;
13455 
13456  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
13457  SWIG_fail;
13458  }
13459  ecode1 = SWIG_AsVal_double(args(0), &val1);
13460  if (!SWIG_IsOK(ecode1)) {
13461  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
13462  }
13463  arg1 = (PLFLT)(val1);
13464  ecode2 = SWIG_AsVal_double(args(1), &val2);
13465  if (!SWIG_IsOK(ecode2)) {
13466  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
13467  }
13468  arg2 = (PLFLT)(val2);
13469  ecode3 = SWIG_AsVal_double(args(2), &val3);
13470  if (!SWIG_IsOK(ecode3)) {
13471  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
13472  }
13473  arg3 = (PLFLT)(val3);
13474  ecode4 = SWIG_AsVal_double(args(3), &val4);
13475  if (!SWIG_IsOK(ecode4)) {
13476  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
13477  }
13478  arg4 = (PLFLT)(val4);
13479  ecode5 = SWIG_AsVal_double(args(4), &val5);
13480  if (!SWIG_IsOK(ecode5)) {
13481  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
13482  }
13483  arg5 = (PLFLT)(val5);
13484  ecode6 = SWIG_AsVal_double(args(5), &val6);
13485  if (!SWIG_IsOK(ecode6)) {
13486  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
13487  }
13488  arg6 = (PLFLT)(val6);
13489  ecode7 = SWIG_AsVal_double(args(6), &val7);
13490  if (!SWIG_IsOK(ecode7)) {
13491  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
13492  }
13493  arg7 = (PLFLT)(val7);
13494  ecode8 = SWIG_AsVal_int(args(7), &val8);
13495  if (!SWIG_IsOK(ecode8)) {
13496  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
13497  }
13498  arg8 = (PLBOOL)(val8);
13499  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
13500  _outv = octave_value();
13501  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13502  return _out;
13503 fail:
13504  return octave_value_list();
13505 }
13506 
13507 
13508 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
13509  PLFLT arg1 ;
13510  PLFLT arg2 ;
13511  char *arg3 = (char *) 0 ;
13512  PLFLT arg4 ;
13513  PLINT arg5 ;
13514  char *arg6 = (char *) 0 ;
13515  PLFLT arg7 ;
13516  PLINT arg8 ;
13517  double val1 ;
13518  int ecode1 = 0 ;
13519  double val2 ;
13520  int ecode2 = 0 ;
13521  int res3 ;
13522  char *buf3 = 0 ;
13523  int alloc3 = 0 ;
13524  double val4 ;
13525  int ecode4 = 0 ;
13526  int val5 ;
13527  int ecode5 = 0 ;
13528  int res6 ;
13529  char *buf6 = 0 ;
13530  int alloc6 = 0 ;
13531  double val7 ;
13532  int ecode7 = 0 ;
13533  int val8 ;
13534  int ecode8 = 0 ;
13535  octave_value_list _out;
13536  octave_value_list *_outp=&_out;
13537  octave_value _outv;
13538 
13539  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
13540  SWIG_fail;
13541  }
13542  ecode1 = SWIG_AsVal_double(args(0), &val1);
13543  if (!SWIG_IsOK(ecode1)) {
13544  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
13545  }
13546  arg1 = (PLFLT)(val1);
13547  ecode2 = SWIG_AsVal_double(args(1), &val2);
13548  if (!SWIG_IsOK(ecode2)) {
13549  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
13550  }
13551  arg2 = (PLFLT)(val2);
13552  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
13553  if (!SWIG_IsOK(res3)) {
13554  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
13555  }
13556  arg3 = (char *)(buf3);
13557  ecode4 = SWIG_AsVal_double(args(3), &val4);
13558  if (!SWIG_IsOK(ecode4)) {
13559  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
13560  }
13561  arg4 = (PLFLT)(val4);
13562  ecode5 = SWIG_AsVal_int(args(4), &val5);
13563  if (!SWIG_IsOK(ecode5)) {
13564  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
13565  }
13566  arg5 = (PLINT)(val5);
13567  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13568  if (!SWIG_IsOK(res6)) {
13569  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
13570  }
13571  arg6 = (char *)(buf6);
13572  ecode7 = SWIG_AsVal_double(args(6), &val7);
13573  if (!SWIG_IsOK(ecode7)) {
13574  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
13575  }
13576  arg7 = (PLFLT)(val7);
13577  ecode8 = SWIG_AsVal_int(args(7), &val8);
13578  if (!SWIG_IsOK(ecode8)) {
13579  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
13580  }
13581  arg8 = (PLINT)(val8);
13582  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
13583  _outv = octave_value();
13584  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13585  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
13586  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13587  return _out;
13588 fail:
13589  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
13590  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13591  return octave_value_list();
13592 }
13593 
13594 
13595 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
13596  PLINT arg1 ;
13597  PLFLT *arg2 = (PLFLT *) 0 ;
13598  PLFLT *arg3 = (PLFLT *) 0 ;
13599  PLINT arg4 ;
13600  Matrix temp1 ;
13601  Matrix temp3 ;
13602  int val4 ;
13603  int ecode4 = 0 ;
13604  octave_value_list _out;
13605  octave_value_list *_outp=&_out;
13606  octave_value _outv;
13607 
13608  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
13609  SWIG_fail;
13610  }
13611  {
13612  if ( _n_dims( args(0) ) > 1 )
13613  {
13614  error( "argument must be a scalar or vector" ); SWIG_fail;
13615  }
13616  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
13617  temp1 = args(0).matrix_value();
13618  arg2 = &temp1( 0, 0 );
13619  }
13620  {
13621  if ( _n_dims( args(1) ) > 1 )
13622  {
13623  error( "argument must be a scalar or vector" ); SWIG_fail;
13624  }
13625  if ( _dim( args(1), 0 ) != Alen )
13626  {
13627  error( "argument vectors must be same length" ); SWIG_fail;
13628  }
13629  temp3 = args(1).matrix_value();
13630  arg3 = &temp3( 0, 0 );
13631  }
13632  ecode4 = SWIG_AsVal_int(args(2), &val4);
13633  if (!SWIG_IsOK(ecode4)) {
13634  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
13635  }
13636  arg4 = (PLINT)(val4);
13637  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
13638  _outv = octave_value();
13639  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13640  {
13641 
13642  }
13643  {
13644 
13645  }
13646  return _out;
13647 fail:
13648  {
13649 
13650  }
13651  {
13652 
13653  }
13654  return octave_value_list();
13655 }
13656 
13657 
13658 SWIG_DEFUN( plbtime, _wrap_plbtime, std::string() ) {
13659  PLINT *arg1 = (PLINT *) 0 ;
13660  PLINT *arg2 = (PLINT *) 0 ;
13661  PLINT *arg3 = (PLINT *) 0 ;
13662  PLINT *arg4 = (PLINT *) 0 ;
13663  PLINT *arg5 = (PLINT *) 0 ;
13664  PLFLT *arg6 = (PLFLT *) 0 ;
13665  PLFLT arg7 ;
13666  PLINT temp1 ;
13667  int res1 = SWIG_TMPOBJ ;
13668  PLINT temp2 ;
13669  int res2 = SWIG_TMPOBJ ;
13670  PLINT temp3 ;
13671  int res3 = SWIG_TMPOBJ ;
13672  PLINT temp4 ;
13673  int res4 = SWIG_TMPOBJ ;
13674  PLINT temp5 ;
13675  int res5 = SWIG_TMPOBJ ;
13676  PLFLT temp6 ;
13677  int res6 = SWIG_TMPOBJ ;
13678  double val7 ;
13679  int ecode7 = 0 ;
13680  octave_value_list _out;
13681  octave_value_list *_outp=&_out;
13682  octave_value _outv;
13683 
13684  arg1 = &temp1;
13685  arg2 = &temp2;
13686  arg3 = &temp3;
13687  arg4 = &temp4;
13688  arg5 = &temp5;
13689  arg6 = &temp6;
13690  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
13691  SWIG_fail;
13692  }
13693  ecode7 = SWIG_AsVal_double(args(0), &val7);
13694  if (!SWIG_IsOK(ecode7)) {
13695  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
13696  }
13697  arg7 = (PLFLT)(val7);
13698  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13699  _outv = octave_value();
13700  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13701  if (SWIG_IsTmpObj(res1)) {
13702  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
13703  } else {
13704  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13705  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13706  }
13707  if (SWIG_IsTmpObj(res2)) {
13708  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
13709  } else {
13710  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13711  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13712  }
13713  if (SWIG_IsTmpObj(res3)) {
13714  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
13715  } else {
13716  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13717  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13718  }
13719  if (SWIG_IsTmpObj(res4)) {
13720  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
13721  } else {
13722  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13723  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
13724  }
13725  if (SWIG_IsTmpObj(res5)) {
13726  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
13727  } else {
13728  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13729  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
13730  }
13731  if (SWIG_IsTmpObj(res6)) {
13732  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
13733  } else {
13734  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13735  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
13736  }
13737  return _out;
13738 fail:
13739  return octave_value_list();
13740 }
13741 
13742 
13743 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
13744  octave_value_list _out;
13745  octave_value_list *_outp=&_out;
13746  octave_value _outv;
13747 
13748  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
13749  SWIG_fail;
13750  }
13751  plbop();
13752  _outv = octave_value();
13753  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13754  return _out;
13755 fail:
13756  return octave_value_list();
13757 }
13758 
13759 
13760 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
13761  char *arg1 = (char *) 0 ;
13762  PLFLT arg2 ;
13763  PLINT arg3 ;
13764  char *arg4 = (char *) 0 ;
13765  PLFLT arg5 ;
13766  PLINT arg6 ;
13767  int res1 ;
13768  char *buf1 = 0 ;
13769  int alloc1 = 0 ;
13770  double val2 ;
13771  int ecode2 = 0 ;
13772  int val3 ;
13773  int ecode3 = 0 ;
13774  int res4 ;
13775  char *buf4 = 0 ;
13776  int alloc4 = 0 ;
13777  double val5 ;
13778  int ecode5 = 0 ;
13779  int val6 ;
13780  int ecode6 = 0 ;
13781  octave_value_list _out;
13782  octave_value_list *_outp=&_out;
13783  octave_value _outv;
13784 
13785  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
13786  SWIG_fail;
13787  }
13788  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13789  if (!SWIG_IsOK(res1)) {
13790  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
13791  }
13792  arg1 = (char *)(buf1);
13793  ecode2 = SWIG_AsVal_double(args(1), &val2);
13794  if (!SWIG_IsOK(ecode2)) {
13795  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
13796  }
13797  arg2 = (PLFLT)(val2);
13798  ecode3 = SWIG_AsVal_int(args(2), &val3);
13799  if (!SWIG_IsOK(ecode3)) {
13800  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
13801  }
13802  arg3 = (PLINT)(val3);
13803  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
13804  if (!SWIG_IsOK(res4)) {
13805  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
13806  }
13807  arg4 = (char *)(buf4);
13808  ecode5 = SWIG_AsVal_double(args(4), &val5);
13809  if (!SWIG_IsOK(ecode5)) {
13810  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
13811  }
13812  arg5 = (PLFLT)(val5);
13813  ecode6 = SWIG_AsVal_int(args(5), &val6);
13814  if (!SWIG_IsOK(ecode6)) {
13815  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
13816  }
13817  arg6 = (PLINT)(val6);
13818  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
13819  _outv = octave_value();
13820  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13821  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13822  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13823  return _out;
13824 fail:
13825  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13826  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13827  return octave_value_list();
13828 }
13829 
13830 
13831 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
13832  char *arg1 = (char *) 0 ;
13833  char *arg2 = (char *) 0 ;
13834  PLFLT arg3 ;
13835  PLINT arg4 ;
13836  char *arg5 = (char *) 0 ;
13837  char *arg6 = (char *) 0 ;
13838  PLFLT arg7 ;
13839  PLINT arg8 ;
13840  char *arg9 = (char *) 0 ;
13841  char *arg10 = (char *) 0 ;
13842  PLFLT arg11 ;
13843  PLINT arg12 ;
13844  int res1 ;
13845  char *buf1 = 0 ;
13846  int alloc1 = 0 ;
13847  int res2 ;
13848  char *buf2 = 0 ;
13849  int alloc2 = 0 ;
13850  double val3 ;
13851  int ecode3 = 0 ;
13852  int val4 ;
13853  int ecode4 = 0 ;
13854  int res5 ;
13855  char *buf5 = 0 ;
13856  int alloc5 = 0 ;
13857  int res6 ;
13858  char *buf6 = 0 ;
13859  int alloc6 = 0 ;
13860  double val7 ;
13861  int ecode7 = 0 ;
13862  int val8 ;
13863  int ecode8 = 0 ;
13864  int res9 ;
13865  char *buf9 = 0 ;
13866  int alloc9 = 0 ;
13867  int res10 ;
13868  char *buf10 = 0 ;
13869  int alloc10 = 0 ;
13870  double val11 ;
13871  int ecode11 = 0 ;
13872  int val12 ;
13873  int ecode12 = 0 ;
13874  octave_value_list _out;
13875  octave_value_list *_outp=&_out;
13876  octave_value _outv;
13877 
13878  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
13879  SWIG_fail;
13880  }
13881  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13882  if (!SWIG_IsOK(res1)) {
13883  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
13884  }
13885  arg1 = (char *)(buf1);
13886  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
13887  if (!SWIG_IsOK(res2)) {
13888  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
13889  }
13890  arg2 = (char *)(buf2);
13891  ecode3 = SWIG_AsVal_double(args(2), &val3);
13892  if (!SWIG_IsOK(ecode3)) {
13893  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
13894  }
13895  arg3 = (PLFLT)(val3);
13896  ecode4 = SWIG_AsVal_int(args(3), &val4);
13897  if (!SWIG_IsOK(ecode4)) {
13898  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
13899  }
13900  arg4 = (PLINT)(val4);
13901  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
13902  if (!SWIG_IsOK(res5)) {
13903  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
13904  }
13905  arg5 = (char *)(buf5);
13906  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13907  if (!SWIG_IsOK(res6)) {
13908  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
13909  }
13910  arg6 = (char *)(buf6);
13911  ecode7 = SWIG_AsVal_double(args(6), &val7);
13912  if (!SWIG_IsOK(ecode7)) {
13913  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
13914  }
13915  arg7 = (PLFLT)(val7);
13916  ecode8 = SWIG_AsVal_int(args(7), &val8);
13917  if (!SWIG_IsOK(ecode8)) {
13918  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
13919  }
13920  arg8 = (PLINT)(val8);
13921  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
13922  if (!SWIG_IsOK(res9)) {
13923  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
13924  }
13925  arg9 = (char *)(buf9);
13926  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
13927  if (!SWIG_IsOK(res10)) {
13928  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
13929  }
13930  arg10 = (char *)(buf10);
13931  ecode11 = SWIG_AsVal_double(args(10), &val11);
13932  if (!SWIG_IsOK(ecode11)) {
13933  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
13934  }
13935  arg11 = (PLFLT)(val11);
13936  ecode12 = SWIG_AsVal_int(args(11), &val12);
13937  if (!SWIG_IsOK(ecode12)) {
13938  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
13939  }
13940  arg12 = (PLINT)(val12);
13941  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);
13942  _outv = octave_value();
13943  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13944  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13945  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13946  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13947  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13948  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
13949  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
13950  return _out;
13951 fail:
13952  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13953  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13954  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13955  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13956  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
13957  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
13958  return octave_value_list();
13959 }
13960 
13961 
13962 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
13963  PLFLT arg1 ;
13964  PLFLT arg2 ;
13965  PLFLT *arg3 = (PLFLT *) 0 ;
13966  PLFLT *arg4 = (PLFLT *) 0 ;
13967  PLINT *arg5 = (PLINT *) 0 ;
13968  double val1 ;
13969  int ecode1 = 0 ;
13970  double val2 ;
13971  int ecode2 = 0 ;
13972  PLFLT temp3 ;
13973  int res3 = SWIG_TMPOBJ ;
13974  PLFLT temp4 ;
13975  int res4 = SWIG_TMPOBJ ;
13976  PLINT temp5 ;
13977  int res5 = SWIG_TMPOBJ ;
13978  octave_value_list _out;
13979  octave_value_list *_outp=&_out;
13980  octave_value _outv;
13981 
13982  arg3 = &temp3;
13983  arg4 = &temp4;
13984  arg5 = &temp5;
13985  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
13986  SWIG_fail;
13987  }
13988  ecode1 = SWIG_AsVal_double(args(0), &val1);
13989  if (!SWIG_IsOK(ecode1)) {
13990  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
13991  }
13992  arg1 = (PLFLT)(val1);
13993  ecode2 = SWIG_AsVal_double(args(1), &val2);
13994  if (!SWIG_IsOK(ecode2)) {
13995  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
13996  }
13997  arg2 = (PLFLT)(val2);
13998  plcalc_world(arg1,arg2,arg3,arg4,arg5);
13999  _outv = octave_value();
14000  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14001  if (SWIG_IsTmpObj(res3)) {
14002  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
14003  } else {
14004  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14005  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
14006  }
14007  if (SWIG_IsTmpObj(res4)) {
14008  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14009  } else {
14010  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14011  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14012  }
14013  if (SWIG_IsTmpObj(res5)) {
14014  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
14015  } else {
14016  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14017  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
14018  }
14019  return _out;
14020 fail:
14021  return octave_value_list();
14022 }
14023 
14024 
14025 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
14026  octave_value_list _out;
14027  octave_value_list *_outp=&_out;
14028  octave_value _outv;
14029 
14030  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
14031  SWIG_fail;
14032  }
14033  plclear();
14034  _outv = octave_value();
14035  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14036  return _out;
14037 fail:
14038  return octave_value_list();
14039 }
14040 
14041 
14042 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
14043  PLINT arg1 ;
14044  int val1 ;
14045  int ecode1 = 0 ;
14046  octave_value_list _out;
14047  octave_value_list *_outp=&_out;
14048  octave_value _outv;
14049 
14050  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
14051  SWIG_fail;
14052  }
14053  ecode1 = SWIG_AsVal_int(args(0), &val1);
14054  if (!SWIG_IsOK(ecode1)) {
14055  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
14056  }
14057  arg1 = (PLINT)(val1);
14058  plcol0(arg1);
14059  _outv = octave_value();
14060  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14061  return _out;
14062 fail:
14063  return octave_value_list();
14064 }
14065 
14066 
14067 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
14068  PLFLT arg1 ;
14069  double val1 ;
14070  int ecode1 = 0 ;
14071  octave_value_list _out;
14072  octave_value_list *_outp=&_out;
14073  octave_value _outv;
14074 
14075  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
14076  SWIG_fail;
14077  }
14078  ecode1 = SWIG_AsVal_double(args(0), &val1);
14079  if (!SWIG_IsOK(ecode1)) {
14080  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
14081  }
14082  arg1 = (PLFLT)(val1);
14083  plcol1(arg1);
14084  _outv = octave_value();
14085  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14086  return _out;
14087 fail:
14088  return octave_value_list();
14089 }
14090 
14091 
14093  PLFLT arg1 ;
14094  PLFLT arg2 ;
14095  PLFLT arg3 ;
14096  PLINT arg4 ;
14097  PLBOOL arg5 ;
14098  PLINT arg6 ;
14099  PLINT arg7 ;
14100  PLINT arg8 ;
14101  PLINT arg9 ;
14102  PLINT arg10 ;
14103  PLFLT arg11 ;
14104  double val1 ;
14105  int ecode1 = 0 ;
14106  double val2 ;
14107  int ecode2 = 0 ;
14108  double val3 ;
14109  int ecode3 = 0 ;
14110  int val4 ;
14111  int ecode4 = 0 ;
14112  int val5 ;
14113  int ecode5 = 0 ;
14114  int val6 ;
14115  int ecode6 = 0 ;
14116  int val7 ;
14117  int ecode7 = 0 ;
14118  int val8 ;
14119  int ecode8 = 0 ;
14120  int val9 ;
14121  int ecode9 = 0 ;
14122  int val10 ;
14123  int ecode10 = 0 ;
14124  double val11 ;
14125  int ecode11 = 0 ;
14126  octave_value_list _out;
14127  octave_value_list *_outp=&_out;
14128  octave_value _outv;
14129 
14130  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
14131  SWIG_fail;
14132  }
14133  ecode1 = SWIG_AsVal_double(args(0), &val1);
14134  if (!SWIG_IsOK(ecode1)) {
14135  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
14136  }
14137  arg1 = (PLFLT)(val1);
14138  ecode2 = SWIG_AsVal_double(args(1), &val2);
14139  if (!SWIG_IsOK(ecode2)) {
14140  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
14141  }
14142  arg2 = (PLFLT)(val2);
14143  ecode3 = SWIG_AsVal_double(args(2), &val3);
14144  if (!SWIG_IsOK(ecode3)) {
14145  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
14146  }
14147  arg3 = (PLFLT)(val3);
14148  ecode4 = SWIG_AsVal_int(args(3), &val4);
14149  if (!SWIG_IsOK(ecode4)) {
14150  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
14151  }
14152  arg4 = (PLINT)(val4);
14153  ecode5 = SWIG_AsVal_int(args(4), &val5);
14154  if (!SWIG_IsOK(ecode5)) {
14155  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
14156  }
14157  arg5 = (PLBOOL)(val5);
14158  ecode6 = SWIG_AsVal_int(args(5), &val6);
14159  if (!SWIG_IsOK(ecode6)) {
14160  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
14161  }
14162  arg6 = (PLINT)(val6);
14163  ecode7 = SWIG_AsVal_int(args(6), &val7);
14164  if (!SWIG_IsOK(ecode7)) {
14165  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
14166  }
14167  arg7 = (PLINT)(val7);
14168  ecode8 = SWIG_AsVal_int(args(7), &val8);
14169  if (!SWIG_IsOK(ecode8)) {
14170  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
14171  }
14172  arg8 = (PLINT)(val8);
14173  ecode9 = SWIG_AsVal_int(args(8), &val9);
14174  if (!SWIG_IsOK(ecode9)) {
14175  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
14176  }
14177  arg9 = (PLINT)(val9);
14178  ecode10 = SWIG_AsVal_int(args(9), &val10);
14179  if (!SWIG_IsOK(ecode10)) {
14180  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
14181  }
14182  arg10 = (PLINT)(val10);
14183  ecode11 = SWIG_AsVal_double(args(10), &val11);
14184  if (!SWIG_IsOK(ecode11)) {
14185  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
14186  }
14187  arg11 = (PLFLT)(val11);
14188  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14189  _outv = octave_value();
14190  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14191  return _out;
14192 fail:
14193  return octave_value_list();
14194 }
14195 
14196 
14197 SWIG_DEFUN( plctime, _wrap_plctime, std::string() ) {
14198  PLINT arg1 ;
14199  PLINT arg2 ;
14200  PLINT arg3 ;
14201  PLINT arg4 ;
14202  PLINT arg5 ;
14203  PLFLT arg6 ;
14204  PLFLT *arg7 = (PLFLT *) 0 ;
14205  int val1 ;
14206  int ecode1 = 0 ;
14207  int val2 ;
14208  int ecode2 = 0 ;
14209  int val3 ;
14210  int ecode3 = 0 ;
14211  int val4 ;
14212  int ecode4 = 0 ;
14213  int val5 ;
14214  int ecode5 = 0 ;
14215  double val6 ;
14216  int ecode6 = 0 ;
14217  PLFLT temp7 ;
14218  int res7 = SWIG_TMPOBJ ;
14219  octave_value_list _out;
14220  octave_value_list *_outp=&_out;
14221  octave_value _outv;
14222 
14223  arg7 = &temp7;
14224  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
14225  SWIG_fail;
14226  }
14227  ecode1 = SWIG_AsVal_int(args(0), &val1);
14228  if (!SWIG_IsOK(ecode1)) {
14229  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
14230  }
14231  arg1 = (PLINT)(val1);
14232  ecode2 = SWIG_AsVal_int(args(1), &val2);
14233  if (!SWIG_IsOK(ecode2)) {
14234  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
14235  }
14236  arg2 = (PLINT)(val2);
14237  ecode3 = SWIG_AsVal_int(args(2), &val3);
14238  if (!SWIG_IsOK(ecode3)) {
14239  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
14240  }
14241  arg3 = (PLINT)(val3);
14242  ecode4 = SWIG_AsVal_int(args(3), &val4);
14243  if (!SWIG_IsOK(ecode4)) {
14244  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
14245  }
14246  arg4 = (PLINT)(val4);
14247  ecode5 = SWIG_AsVal_int(args(4), &val5);
14248  if (!SWIG_IsOK(ecode5)) {
14249  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
14250  }
14251  arg5 = (PLINT)(val5);
14252  ecode6 = SWIG_AsVal_double(args(5), &val6);
14253  if (!SWIG_IsOK(ecode6)) {
14254  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
14255  }
14256  arg6 = (PLFLT)(val6);
14257  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14258  _outv = octave_value();
14259  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14260  if (SWIG_IsTmpObj(res7)) {
14261  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
14262  } else {
14263  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14264  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
14265  }
14266  return _out;
14267 fail:
14268  return octave_value_list();
14269 }
14270 
14271 
14272 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
14273  PLINT arg1 ;
14274  PLBOOL arg2 ;
14275  int val1 ;
14276  int ecode1 = 0 ;
14277  int val2 ;
14278  int ecode2 = 0 ;
14279  octave_value_list _out;
14280  octave_value_list *_outp=&_out;
14281  octave_value _outv;
14282 
14283  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
14284  SWIG_fail;
14285  }
14286  ecode1 = SWIG_AsVal_int(args(0), &val1);
14287  if (!SWIG_IsOK(ecode1)) {
14288  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
14289  }
14290  arg1 = (PLINT)(val1);
14291  ecode2 = SWIG_AsVal_int(args(1), &val2);
14292  if (!SWIG_IsOK(ecode2)) {
14293  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
14294  }
14295  arg2 = (PLBOOL)(val2);
14296  plcpstrm(arg1,arg2);
14297  _outv = octave_value();
14298  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14299  return _out;
14300 fail:
14301  return octave_value_list();
14302 }
14303 
14304 
14305 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
14306  octave_value_list _out;
14307  octave_value_list *_outp=&_out;
14308  octave_value _outv;
14309 
14310  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
14311  SWIG_fail;
14312  }
14313  plend();
14314  _outv = octave_value();
14315  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14316  return _out;
14317 fail:
14318  return octave_value_list();
14319 }
14320 
14321 
14322 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
14323  octave_value_list _out;
14324  octave_value_list *_outp=&_out;
14325  octave_value _outv;
14326 
14327  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
14328  SWIG_fail;
14329  }
14330  plend1();
14331  _outv = octave_value();
14332  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14333  return _out;
14334 fail:
14335  return octave_value_list();
14336 }
14337 
14338 
14339 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
14340  PLFLT arg1 ;
14341  PLFLT arg2 ;
14342  PLFLT arg3 ;
14343  PLFLT arg4 ;
14344  PLINT arg5 ;
14345  PLINT arg6 ;
14346  double val1 ;
14347  int ecode1 = 0 ;
14348  double val2 ;
14349  int ecode2 = 0 ;
14350  double val3 ;
14351  int ecode3 = 0 ;
14352  double val4 ;
14353  int ecode4 = 0 ;
14354  int val5 ;
14355  int ecode5 = 0 ;
14356  int val6 ;
14357  int ecode6 = 0 ;
14358  octave_value_list _out;
14359  octave_value_list *_outp=&_out;
14360  octave_value _outv;
14361 
14362  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
14363  SWIG_fail;
14364  }
14365  ecode1 = SWIG_AsVal_double(args(0), &val1);
14366  if (!SWIG_IsOK(ecode1)) {
14367  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
14368  }
14369  arg1 = (PLFLT)(val1);
14370  ecode2 = SWIG_AsVal_double(args(1), &val2);
14371  if (!SWIG_IsOK(ecode2)) {
14372  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
14373  }
14374  arg2 = (PLFLT)(val2);
14375  ecode3 = SWIG_AsVal_double(args(2), &val3);
14376  if (!SWIG_IsOK(ecode3)) {
14377  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
14378  }
14379  arg3 = (PLFLT)(val3);
14380  ecode4 = SWIG_AsVal_double(args(3), &val4);
14381  if (!SWIG_IsOK(ecode4)) {
14382  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
14383  }
14384  arg4 = (PLFLT)(val4);
14385  ecode5 = SWIG_AsVal_int(args(4), &val5);
14386  if (!SWIG_IsOK(ecode5)) {
14387  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
14388  }
14389  arg5 = (PLINT)(val5);
14390  ecode6 = SWIG_AsVal_int(args(5), &val6);
14391  if (!SWIG_IsOK(ecode6)) {
14392  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
14393  }
14394  arg6 = (PLINT)(val6);
14395  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
14396  _outv = octave_value();
14397  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14398  return _out;
14399 fail:
14400  return octave_value_list();
14401 }
14402 
14403 
14404 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
14405  PLFLT arg1 ;
14406  PLFLT arg2 ;
14407  PLFLT arg3 ;
14408  PLFLT arg4 ;
14409  PLINT arg5 ;
14410  PLINT arg6 ;
14411  double val1 ;
14412  int ecode1 = 0 ;
14413  double val2 ;
14414  int ecode2 = 0 ;
14415  double val3 ;
14416  int ecode3 = 0 ;
14417  double val4 ;
14418  int ecode4 = 0 ;
14419  int val5 ;
14420  int ecode5 = 0 ;
14421  int val6 ;
14422  int ecode6 = 0 ;
14423  octave_value_list _out;
14424  octave_value_list *_outp=&_out;
14425  octave_value _outv;
14426 
14427  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
14428  SWIG_fail;
14429  }
14430  ecode1 = SWIG_AsVal_double(args(0), &val1);
14431  if (!SWIG_IsOK(ecode1)) {
14432  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
14433  }
14434  arg1 = (PLFLT)(val1);
14435  ecode2 = SWIG_AsVal_double(args(1), &val2);
14436  if (!SWIG_IsOK(ecode2)) {
14437  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
14438  }
14439  arg2 = (PLFLT)(val2);
14440  ecode3 = SWIG_AsVal_double(args(2), &val3);
14441  if (!SWIG_IsOK(ecode3)) {
14442  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
14443  }
14444  arg3 = (PLFLT)(val3);
14445  ecode4 = SWIG_AsVal_double(args(3), &val4);
14446  if (!SWIG_IsOK(ecode4)) {
14447  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
14448  }
14449  arg4 = (PLFLT)(val4);
14450  ecode5 = SWIG_AsVal_int(args(4), &val5);
14451  if (!SWIG_IsOK(ecode5)) {
14452  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
14453  }
14454  arg5 = (PLINT)(val5);
14455  ecode6 = SWIG_AsVal_int(args(5), &val6);
14456  if (!SWIG_IsOK(ecode6)) {
14457  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
14458  }
14459  arg6 = (PLINT)(val6);
14460  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
14461  _outv = octave_value();
14462  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14463  return _out;
14464 fail:
14465  return octave_value_list();
14466 }
14467 
14468 
14469 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
14470  octave_value_list _out;
14471  octave_value_list *_outp=&_out;
14472  octave_value _outv;
14473 
14474  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
14475  SWIG_fail;
14476  }
14477  pleop();
14478  _outv = octave_value();
14479  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14480  return _out;
14481 fail:
14482  return octave_value_list();
14483 }
14484 
14485 
14486 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
14487  PLINT arg1 ;
14488  PLFLT *arg2 = (PLFLT *) 0 ;
14489  PLFLT *arg3 = (PLFLT *) 0 ;
14490  PLFLT *arg4 = (PLFLT *) 0 ;
14491  Matrix temp1 ;
14492  Matrix temp3 ;
14493  Matrix temp4 ;
14494  octave_value_list _out;
14495  octave_value_list *_outp=&_out;
14496  octave_value _outv;
14497 
14498  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
14499  SWIG_fail;
14500  }
14501  {
14502  if ( _n_dims( args(0) ) > 1 )
14503  {
14504  error( "argument must be a scalar or vector" ); SWIG_fail;
14505  }
14506  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14507  temp1 = args(0).matrix_value();
14508  arg2 = &temp1( 0, 0 );
14509  }
14510  {
14511  if ( _n_dims( args(1) ) > 1 )
14512  {
14513  error( "argument must be a scalar or vector" ); SWIG_fail;
14514  }
14515  if ( _dim( args(1), 0 ) != Alen )
14516  {
14517  error( "argument vectors must be same length" ); SWIG_fail;
14518  }
14519  temp3 = args(1).matrix_value();
14520  arg3 = &temp3( 0, 0 );
14521  }
14522  {
14523  if ( _n_dims( args(2) ) > 1 )
14524  {
14525  error( "argument must be a scalar or vector" ); SWIG_fail;
14526  }
14527  if ( _dim( args(2), 0 ) != Alen )
14528  {
14529  error( "argument vectors must be same length" ); SWIG_fail;
14530  }
14531  temp4 = args(2).matrix_value();
14532  arg4 = &temp4( 0, 0 );
14533  }
14534  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14535  _outv = octave_value();
14536  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14537  {
14538 
14539  }
14540  {
14541 
14542  }
14543  {
14544 
14545  }
14546  return _out;
14547 fail:
14548  {
14549 
14550  }
14551  {
14552 
14553  }
14554  {
14555 
14556  }
14557  return octave_value_list();
14558 }
14559 
14560 
14561 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
14562  PLINT arg1 ;
14563  PLFLT *arg2 = (PLFLT *) 0 ;
14564  PLFLT *arg3 = (PLFLT *) 0 ;
14565  PLFLT *arg4 = (PLFLT *) 0 ;
14566  Matrix temp1 ;
14567  Matrix temp3 ;
14568  Matrix temp4 ;
14569  octave_value_list _out;
14570  octave_value_list *_outp=&_out;
14571  octave_value _outv;
14572 
14573  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
14574  SWIG_fail;
14575  }
14576  {
14577  if ( _n_dims( args(0) ) > 1 )
14578  {
14579  error( "argument must be a scalar or vector" ); SWIG_fail;
14580  }
14581  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14582  temp1 = args(0).matrix_value();
14583  arg2 = &temp1( 0, 0 );
14584  }
14585  {
14586  if ( _n_dims( args(1) ) > 1 )
14587  {
14588  error( "argument must be a scalar or vector" ); SWIG_fail;
14589  }
14590  if ( _dim( args(1), 0 ) != Alen )
14591  {
14592  error( "argument vectors must be same length" ); SWIG_fail;
14593  }
14594  temp3 = args(1).matrix_value();
14595  arg3 = &temp3( 0, 0 );
14596  }
14597  {
14598  if ( _n_dims( args(2) ) > 1 )
14599  {
14600  error( "argument must be a scalar or vector" ); SWIG_fail;
14601  }
14602  if ( _dim( args(2), 0 ) != Alen )
14603  {
14604  error( "argument vectors must be same length" ); SWIG_fail;
14605  }
14606  temp4 = args(2).matrix_value();
14607  arg4 = &temp4( 0, 0 );
14608  }
14609  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14610  _outv = octave_value();
14611  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14612  {
14613 
14614  }
14615  {
14616 
14617  }
14618  {
14619 
14620  }
14621  return _out;
14622 fail:
14623  {
14624 
14625  }
14626  {
14627 
14628  }
14629  {
14630 
14631  }
14632  return octave_value_list();
14633 }
14634 
14635 
14636 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
14637  octave_value_list _out;
14638  octave_value_list *_outp=&_out;
14639  octave_value _outv;
14640 
14641  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
14642  SWIG_fail;
14643  }
14644  plfamadv();
14645  _outv = octave_value();
14646  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14647  return _out;
14648 fail:
14649  return octave_value_list();
14650 }
14651 
14652 
14653 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
14654  PLINT arg1 ;
14655  PLFLT *arg2 = (PLFLT *) 0 ;
14656  PLFLT *arg3 = (PLFLT *) 0 ;
14657  Matrix temp1 ;
14658  Matrix temp3 ;
14659  octave_value_list _out;
14660  octave_value_list *_outp=&_out;
14661  octave_value _outv;
14662 
14663  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
14664  SWIG_fail;
14665  }
14666  {
14667  if ( _n_dims( args(0) ) > 1 )
14668  {
14669  error( "argument must be a scalar or vector" ); SWIG_fail;
14670  }
14671  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14672  temp1 = args(0).matrix_value();
14673  arg2 = &temp1( 0, 0 );
14674  }
14675  {
14676  if ( _n_dims( args(1) ) > 1 )
14677  {
14678  error( "argument must be a scalar or vector" ); SWIG_fail;
14679  }
14680  if ( _dim( args(1), 0 ) != Alen )
14681  {
14682  error( "argument vectors must be same length" ); SWIG_fail;
14683  }
14684  temp3 = args(1).matrix_value();
14685  arg3 = &temp3( 0, 0 );
14686  }
14687  plfill(arg1,(double const *)arg2,(double const *)arg3);
14688  _outv = octave_value();
14689  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14690  {
14691 
14692  }
14693  {
14694 
14695  }
14696  return _out;
14697 fail:
14698  {
14699 
14700  }
14701  {
14702 
14703  }
14704  return octave_value_list();
14705 }
14706 
14707 
14708 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
14709  PLINT arg1 ;
14710  PLFLT *arg2 = (PLFLT *) 0 ;
14711  PLFLT *arg3 = (PLFLT *) 0 ;
14712  PLFLT *arg4 = (PLFLT *) 0 ;
14713  Matrix temp1 ;
14714  Matrix temp3 ;
14715  Matrix temp4 ;
14716  octave_value_list _out;
14717  octave_value_list *_outp=&_out;
14718  octave_value _outv;
14719 
14720  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
14721  SWIG_fail;
14722  }
14723  {
14724  if ( _n_dims( args(0) ) > 1 )
14725  {
14726  error( "argument must be a scalar or vector" ); SWIG_fail;
14727  }
14728  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14729  temp1 = args(0).matrix_value();
14730  arg2 = &temp1( 0, 0 );
14731  }
14732  {
14733  if ( _n_dims( args(1) ) > 1 )
14734  {
14735  error( "argument must be a scalar or vector" ); SWIG_fail;
14736  }
14737  if ( _dim( args(1), 0 ) != Alen )
14738  {
14739  error( "argument vectors must be same length" ); SWIG_fail;
14740  }
14741  temp3 = args(1).matrix_value();
14742  arg3 = &temp3( 0, 0 );
14743  }
14744  {
14745  if ( _n_dims( args(2) ) > 1 )
14746  {
14747  error( "argument must be a scalar or vector" ); SWIG_fail;
14748  }
14749  if ( _dim( args(2), 0 ) != Alen )
14750  {
14751  error( "argument vectors must be same length" ); SWIG_fail;
14752  }
14753  temp4 = args(2).matrix_value();
14754  arg4 = &temp4( 0, 0 );
14755  }
14756  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14757  _outv = octave_value();
14758  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14759  {
14760 
14761  }
14762  {
14763 
14764  }
14765  {
14766 
14767  }
14768  return _out;
14769 fail:
14770  {
14771 
14772  }
14773  {
14774 
14775  }
14776  {
14777 
14778  }
14779  return octave_value_list();
14780 }
14781 
14782 
14783 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
14784  PLINT arg1 ;
14785  PLFLT *arg2 = (PLFLT *) 0 ;
14786  PLFLT *arg3 = (PLFLT *) 0 ;
14787  PLFLT arg4 ;
14788  Matrix temp1 ;
14789  Matrix temp3 ;
14790  double val4 ;
14791  int ecode4 = 0 ;
14792  octave_value_list _out;
14793  octave_value_list *_outp=&_out;
14794  octave_value _outv;
14795 
14796  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
14797  SWIG_fail;
14798  }
14799  {
14800  if ( _n_dims( args(0) ) > 1 )
14801  {
14802  error( "argument must be a scalar or vector" ); SWIG_fail;
14803  }
14804  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14805  temp1 = args(0).matrix_value();
14806  arg2 = &temp1( 0, 0 );
14807  }
14808  {
14809  if ( _n_dims( args(1) ) > 1 )
14810  {
14811  error( "argument must be a scalar or vector" ); SWIG_fail;
14812  }
14813  if ( _dim( args(1), 0 ) != Alen )
14814  {
14815  error( "argument vectors must be same length" ); SWIG_fail;
14816  }
14817  temp3 = args(1).matrix_value();
14818  arg3 = &temp3( 0, 0 );
14819  }
14820  ecode4 = SWIG_AsVal_double(args(2), &val4);
14821  if (!SWIG_IsOK(ecode4)) {
14822  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
14823  }
14824  arg4 = (PLFLT)(val4);
14825  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
14826  _outv = octave_value();
14827  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14828  {
14829 
14830  }
14831  {
14832 
14833  }
14834  return _out;
14835 fail:
14836  {
14837 
14838  }
14839  {
14840 
14841  }
14842  return octave_value_list();
14843 }
14844 
14845 
14846 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
14847  octave_value_list _out;
14848  octave_value_list *_outp=&_out;
14849  octave_value _outv;
14850 
14851  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
14852  SWIG_fail;
14853  }
14854  plflush();
14855  _outv = octave_value();
14856  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14857  return _out;
14858 fail:
14859  return octave_value_list();
14860 }
14861 
14862 
14863 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
14864  PLINT arg1 ;
14865  int val1 ;
14866  int ecode1 = 0 ;
14867  octave_value_list _out;
14868  octave_value_list *_outp=&_out;
14869  octave_value _outv;
14870 
14871  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
14872  SWIG_fail;
14873  }
14874  ecode1 = SWIG_AsVal_int(args(0), &val1);
14875  if (!SWIG_IsOK(ecode1)) {
14876  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
14877  }
14878  arg1 = (PLINT)(val1);
14879  plfont(arg1);
14880  _outv = octave_value();
14881  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14882  return _out;
14883 fail:
14884  return octave_value_list();
14885 }
14886 
14887 
14888 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
14889  PLINT arg1 ;
14890  int val1 ;
14891  int ecode1 = 0 ;
14892  octave_value_list _out;
14893  octave_value_list *_outp=&_out;
14894  octave_value _outv;
14895 
14896  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
14897  SWIG_fail;
14898  }
14899  ecode1 = SWIG_AsVal_int(args(0), &val1);
14900  if (!SWIG_IsOK(ecode1)) {
14901  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
14902  }
14903  arg1 = (PLINT)(val1);
14904  plfontld(arg1);
14905  _outv = octave_value();
14906  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14907  return _out;
14908 fail:
14909  return octave_value_list();
14910 }
14911 
14912 
14913 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
14914  PLFLT *arg1 = (PLFLT *) 0 ;
14915  PLFLT *arg2 = (PLFLT *) 0 ;
14916  PLFLT temp1 ;
14917  int res1 = SWIG_TMPOBJ ;
14918  PLFLT temp2 ;
14919  int res2 = SWIG_TMPOBJ ;
14920  octave_value_list _out;
14921  octave_value_list *_outp=&_out;
14922  octave_value _outv;
14923 
14924  arg1 = &temp1;
14925  arg2 = &temp2;
14926  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
14927  SWIG_fail;
14928  }
14929  plgchr(arg1,arg2);
14930  _outv = octave_value();
14931  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14932  if (SWIG_IsTmpObj(res1)) {
14933  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14934  } else {
14935  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14936  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14937  }
14938  if (SWIG_IsTmpObj(res2)) {
14939  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14940  } else {
14941  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14942  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14943  }
14944  return _out;
14945 fail:
14946  return octave_value_list();
14947 }
14948 
14949 
14950 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
14951  PLINT arg1 ;
14952  PLINT *arg2 = (PLINT *) 0 ;
14953  PLINT *arg3 = (PLINT *) 0 ;
14954  PLINT *arg4 = (PLINT *) 0 ;
14955  int val1 ;
14956  int ecode1 = 0 ;
14957  PLINT temp2 ;
14958  int res2 = SWIG_TMPOBJ ;
14959  PLINT temp3 ;
14960  int res3 = SWIG_TMPOBJ ;
14961  PLINT temp4 ;
14962  int res4 = SWIG_TMPOBJ ;
14963  octave_value_list _out;
14964  octave_value_list *_outp=&_out;
14965  octave_value _outv;
14966 
14967  arg2 = &temp2;
14968  arg3 = &temp3;
14969  arg4 = &temp4;
14970  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
14971  SWIG_fail;
14972  }
14973  ecode1 = SWIG_AsVal_int(args(0), &val1);
14974  if (!SWIG_IsOK(ecode1)) {
14975  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
14976  }
14977  arg1 = (PLINT)(val1);
14978  plgcol0(arg1,arg2,arg3,arg4);
14979  _outv = octave_value();
14980  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14981  if (SWIG_IsTmpObj(res2)) {
14982  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14983  } else {
14984  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14985  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14986  }
14987  if (SWIG_IsTmpObj(res3)) {
14988  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14989  } else {
14990  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14991  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14992  }
14993  if (SWIG_IsTmpObj(res4)) {
14994  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
14995  } else {
14996  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14997  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
14998  }
14999  return _out;
15000 fail:
15001  return octave_value_list();
15002 }
15003 
15004 
15005 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
15006  PLINT arg1 ;
15007  PLINT *arg2 = (PLINT *) 0 ;
15008  PLINT *arg3 = (PLINT *) 0 ;
15009  PLINT *arg4 = (PLINT *) 0 ;
15010  PLFLT *arg5 = (PLFLT *) 0 ;
15011  int val1 ;
15012  int ecode1 = 0 ;
15013  PLINT temp2 ;
15014  int res2 = SWIG_TMPOBJ ;
15015  PLINT temp3 ;
15016  int res3 = SWIG_TMPOBJ ;
15017  PLINT temp4 ;
15018  int res4 = SWIG_TMPOBJ ;
15019  PLFLT temp5 ;
15020  int res5 = SWIG_TMPOBJ ;
15021  octave_value_list _out;
15022  octave_value_list *_outp=&_out;
15023  octave_value _outv;
15024 
15025  arg2 = &temp2;
15026  arg3 = &temp3;
15027  arg4 = &temp4;
15028  arg5 = &temp5;
15029  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
15030  SWIG_fail;
15031  }
15032  ecode1 = SWIG_AsVal_int(args(0), &val1);
15033  if (!SWIG_IsOK(ecode1)) {
15034  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
15035  }
15036  arg1 = (PLINT)(val1);
15037  plgcol0a(arg1,arg2,arg3,arg4,arg5);
15038  _outv = octave_value();
15039  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15040  if (SWIG_IsTmpObj(res2)) {
15041  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15042  } else {
15043  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15044  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15045  }
15046  if (SWIG_IsTmpObj(res3)) {
15047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15048  } else {
15049  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15050  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15051  }
15052  if (SWIG_IsTmpObj(res4)) {
15053  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15054  } else {
15055  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15056  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15057  }
15058  if (SWIG_IsTmpObj(res5)) {
15059  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
15060  } else {
15061  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15062  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15063  }
15064  return _out;
15065 fail:
15066  return octave_value_list();
15067 }
15068 
15069 
15070 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
15071  PLINT *arg1 = (PLINT *) 0 ;
15072  PLINT *arg2 = (PLINT *) 0 ;
15073  PLINT *arg3 = (PLINT *) 0 ;
15074  PLINT temp1 ;
15075  int res1 = SWIG_TMPOBJ ;
15076  PLINT temp2 ;
15077  int res2 = SWIG_TMPOBJ ;
15078  PLINT temp3 ;
15079  int res3 = SWIG_TMPOBJ ;
15080  octave_value_list _out;
15081  octave_value_list *_outp=&_out;
15082  octave_value _outv;
15083 
15084  arg1 = &temp1;
15085  arg2 = &temp2;
15086  arg3 = &temp3;
15087  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
15088  SWIG_fail;
15089  }
15090  plgcolbg(arg1,arg2,arg3);
15091  _outv = octave_value();
15092  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15093  if (SWIG_IsTmpObj(res1)) {
15094  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15095  } else {
15096  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15097  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15098  }
15099  if (SWIG_IsTmpObj(res2)) {
15100  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15101  } else {
15102  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15103  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15104  }
15105  if (SWIG_IsTmpObj(res3)) {
15106  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15107  } else {
15108  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15109  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15110  }
15111  return _out;
15112 fail:
15113  return octave_value_list();
15114 }
15115 
15116 
15117 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
15118  PLINT *arg1 = (PLINT *) 0 ;
15119  PLINT *arg2 = (PLINT *) 0 ;
15120  PLINT *arg3 = (PLINT *) 0 ;
15121  PLFLT *arg4 = (PLFLT *) 0 ;
15122  PLINT temp1 ;
15123  int res1 = SWIG_TMPOBJ ;
15124  PLINT temp2 ;
15125  int res2 = SWIG_TMPOBJ ;
15126  PLINT temp3 ;
15127  int res3 = SWIG_TMPOBJ ;
15128  PLFLT temp4 ;
15129  int res4 = SWIG_TMPOBJ ;
15130  octave_value_list _out;
15131  octave_value_list *_outp=&_out;
15132  octave_value _outv;
15133 
15134  arg1 = &temp1;
15135  arg2 = &temp2;
15136  arg3 = &temp3;
15137  arg4 = &temp4;
15138  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
15139  SWIG_fail;
15140  }
15141  plgcolbga(arg1,arg2,arg3,arg4);
15142  _outv = octave_value();
15143  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15144  if (SWIG_IsTmpObj(res1)) {
15145  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15146  } else {
15147  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15148  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15149  }
15150  if (SWIG_IsTmpObj(res2)) {
15151  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15152  } else {
15153  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15154  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15155  }
15156  if (SWIG_IsTmpObj(res3)) {
15157  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15158  } else {
15159  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15160  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15161  }
15162  if (SWIG_IsTmpObj(res4)) {
15163  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15164  } else {
15165  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15166  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15167  }
15168  return _out;
15169 fail:
15170  return octave_value_list();
15171 }
15172 
15173 
15174 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
15175  PLINT *arg1 = (PLINT *) 0 ;
15176  PLINT temp1 ;
15177  int res1 = SWIG_TMPOBJ ;
15178  octave_value_list _out;
15179  octave_value_list *_outp=&_out;
15180  octave_value _outv;
15181 
15182  arg1 = &temp1;
15183  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
15184  SWIG_fail;
15185  }
15186  plgcompression(arg1);
15187  _outv = octave_value();
15188  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15189  if (SWIG_IsTmpObj(res1)) {
15190  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15191  } else {
15192  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15193  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15194  }
15195  return _out;
15196 fail:
15197  return octave_value_list();
15198 }
15199 
15200 
15201 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
15202  char *arg1 = (char *) 0 ;
15203  octave_value_list retval1 ;
15204  octave_value_list _out;
15205  octave_value_list *_outp=&_out;
15206  octave_value _outv;
15207 
15208  {
15209  // Check if version >= 3.4.0
15210 # if OCTAVE_API_VERSION_NUMBER < 45
15211  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15212 # else
15213  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15214 # endif
15215  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15216  }
15217  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
15218  SWIG_fail;
15219  }
15220  plgdev(arg1);
15221  _outv = octave_value();
15222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15223  {
15224  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15225  }
15226  return _out;
15227 fail:
15228  return octave_value_list();
15229 }
15230 
15231 
15232 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
15233  PLFLT *arg1 = (PLFLT *) 0 ;
15234  PLFLT *arg2 = (PLFLT *) 0 ;
15235  PLFLT *arg3 = (PLFLT *) 0 ;
15236  PLFLT *arg4 = (PLFLT *) 0 ;
15237  PLFLT temp1 ;
15238  int res1 = SWIG_TMPOBJ ;
15239  PLFLT temp2 ;
15240  int res2 = SWIG_TMPOBJ ;
15241  PLFLT temp3 ;
15242  int res3 = SWIG_TMPOBJ ;
15243  PLFLT temp4 ;
15244  int res4 = SWIG_TMPOBJ ;
15245  octave_value_list _out;
15246  octave_value_list *_outp=&_out;
15247  octave_value _outv;
15248 
15249  arg1 = &temp1;
15250  arg2 = &temp2;
15251  arg3 = &temp3;
15252  arg4 = &temp4;
15253  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
15254  SWIG_fail;
15255  }
15256  plgdidev(arg1,arg2,arg3,arg4);
15257  _outv = octave_value();
15258  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15259  if (SWIG_IsTmpObj(res1)) {
15260  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15261  } else {
15262  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15263  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15264  }
15265  if (SWIG_IsTmpObj(res2)) {
15266  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15267  } else {
15268  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15269  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15270  }
15271  if (SWIG_IsTmpObj(res3)) {
15272  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15273  } else {
15274  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15275  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15276  }
15277  if (SWIG_IsTmpObj(res4)) {
15278  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15279  } else {
15280  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15281  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15282  }
15283  return _out;
15284 fail:
15285  return octave_value_list();
15286 }
15287 
15288 
15289 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
15290  PLFLT *arg1 = (PLFLT *) 0 ;
15291  PLFLT temp1 ;
15292  int res1 = SWIG_TMPOBJ ;
15293  octave_value_list _out;
15294  octave_value_list *_outp=&_out;
15295  octave_value _outv;
15296 
15297  arg1 = &temp1;
15298  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
15299  SWIG_fail;
15300  }
15301  plgdiori(arg1);
15302  _outv = octave_value();
15303  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15304  if (SWIG_IsTmpObj(res1)) {
15305  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15306  } else {
15307  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15308  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15309  }
15310  return _out;
15311 fail:
15312  return octave_value_list();
15313 }
15314 
15315 
15316 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
15317  PLFLT *arg1 = (PLFLT *) 0 ;
15318  PLFLT *arg2 = (PLFLT *) 0 ;
15319  PLFLT *arg3 = (PLFLT *) 0 ;
15320  PLFLT *arg4 = (PLFLT *) 0 ;
15321  PLFLT temp1 ;
15322  int res1 = SWIG_TMPOBJ ;
15323  PLFLT temp2 ;
15324  int res2 = SWIG_TMPOBJ ;
15325  PLFLT temp3 ;
15326  int res3 = SWIG_TMPOBJ ;
15327  PLFLT temp4 ;
15328  int res4 = SWIG_TMPOBJ ;
15329  octave_value_list _out;
15330  octave_value_list *_outp=&_out;
15331  octave_value _outv;
15332 
15333  arg1 = &temp1;
15334  arg2 = &temp2;
15335  arg3 = &temp3;
15336  arg4 = &temp4;
15337  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
15338  SWIG_fail;
15339  }
15340  plgdiplt(arg1,arg2,arg3,arg4);
15341  _outv = octave_value();
15342  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15343  if (SWIG_IsTmpObj(res1)) {
15344  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15345  } else {
15346  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15347  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15348  }
15349  if (SWIG_IsTmpObj(res2)) {
15350  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15351  } else {
15352  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15353  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15354  }
15355  if (SWIG_IsTmpObj(res3)) {
15356  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15357  } else {
15358  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15359  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15360  }
15361  if (SWIG_IsTmpObj(res4)) {
15362  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15363  } else {
15364  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15365  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15366  }
15367  return _out;
15368 fail:
15369  return octave_value_list();
15370 }
15371 
15372 
15373 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
15374  PLINT *arg1 = (PLINT *) 0 ;
15375  PLINT *arg2 = (PLINT *) 0 ;
15376  PLINT *arg3 = (PLINT *) 0 ;
15377  PLINT temp1 ;
15378  int res1 = SWIG_TMPOBJ ;
15379  PLINT temp2 ;
15380  int res2 = SWIG_TMPOBJ ;
15381  PLINT temp3 ;
15382  int res3 = SWIG_TMPOBJ ;
15383  octave_value_list _out;
15384  octave_value_list *_outp=&_out;
15385  octave_value _outv;
15386 
15387  arg1 = &temp1;
15388  arg2 = &temp2;
15389  arg3 = &temp3;
15390  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
15391  SWIG_fail;
15392  }
15393  plgfam(arg1,arg2,arg3);
15394  _outv = octave_value();
15395  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15396  if (SWIG_IsTmpObj(res1)) {
15397  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15398  } else {
15399  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15400  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15401  }
15402  if (SWIG_IsTmpObj(res2)) {
15403  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15404  } else {
15405  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15406  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15407  }
15408  if (SWIG_IsTmpObj(res3)) {
15409  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15410  } else {
15411  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15412  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15413  }
15414  return _out;
15415 fail:
15416  return octave_value_list();
15417 }
15418 
15419 
15420 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
15421  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
15422  PLUNICODE temp1 ;
15423  int res1 = SWIG_TMPOBJ ;
15424  octave_value_list _out;
15425  octave_value_list *_outp=&_out;
15426  octave_value _outv;
15427 
15428  arg1 = &temp1;
15429  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
15430  SWIG_fail;
15431  }
15432  plgfci(arg1);
15433  _outv = octave_value();
15434  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15435  if (SWIG_IsTmpObj(res1)) {
15436  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
15437  } else {
15438  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15439  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
15440  }
15441  return _out;
15442 fail:
15443  return octave_value_list();
15444 }
15445 
15446 
15447 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
15448  char *arg1 = (char *) 0 ;
15449  octave_value_list retval1 ;
15450  octave_value_list _out;
15451  octave_value_list *_outp=&_out;
15452  octave_value _outv;
15453 
15454  {
15455  // Check if version >= 3.4.0
15456 # if OCTAVE_API_VERSION_NUMBER < 45
15457  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15458 # else
15459  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15460 # endif
15461  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15462  }
15463  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
15464  SWIG_fail;
15465  }
15466  plgfnam(arg1);
15467  _outv = octave_value();
15468  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15469  {
15470  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15471  }
15472  return _out;
15473 fail:
15474  return octave_value_list();
15475 }
15476 
15477 
15478 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
15479  PLINT *arg1 = (PLINT *) 0 ;
15480  PLINT *arg2 = (PLINT *) 0 ;
15481  PLINT *arg3 = (PLINT *) 0 ;
15482  PLINT temp1 ;
15483  int res1 = SWIG_TMPOBJ ;
15484  PLINT temp2 ;
15485  int res2 = SWIG_TMPOBJ ;
15486  PLINT temp3 ;
15487  int res3 = SWIG_TMPOBJ ;
15488  octave_value_list _out;
15489  octave_value_list *_outp=&_out;
15490  octave_value _outv;
15491 
15492  arg1 = &temp1;
15493  arg2 = &temp2;
15494  arg3 = &temp3;
15495  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
15496  SWIG_fail;
15497  }
15498  plgfont(arg1,arg2,arg3);
15499  _outv = octave_value();
15500  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15501  if (SWIG_IsTmpObj(res1)) {
15502  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15503  } else {
15504  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15505  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15506  }
15507  if (SWIG_IsTmpObj(res2)) {
15508  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15509  } else {
15510  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15511  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15512  }
15513  if (SWIG_IsTmpObj(res3)) {
15514  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15515  } else {
15516  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15517  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15518  }
15519  return _out;
15520 fail:
15521  return octave_value_list();
15522 }
15523 
15524 
15525 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
15526  PLINT *arg1 = (PLINT *) 0 ;
15527  PLINT temp1 ;
15528  int res1 = SWIG_TMPOBJ ;
15529  octave_value_list _out;
15530  octave_value_list *_outp=&_out;
15531  octave_value _outv;
15532 
15533  arg1 = &temp1;
15534  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
15535  SWIG_fail;
15536  }
15537  plglevel(arg1);
15538  _outv = octave_value();
15539  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15540  if (SWIG_IsTmpObj(res1)) {
15541  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15542  } else {
15543  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15544  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15545  }
15546  return _out;
15547 fail:
15548  return octave_value_list();
15549 }
15550 
15551 
15552 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
15553  PLFLT *arg1 = (PLFLT *) 0 ;
15554  PLFLT *arg2 = (PLFLT *) 0 ;
15555  PLINT *arg3 = (PLINT *) 0 ;
15556  PLINT *arg4 = (PLINT *) 0 ;
15557  PLINT *arg5 = (PLINT *) 0 ;
15558  PLINT *arg6 = (PLINT *) 0 ;
15559  PLFLT temp1 ;
15560  int res1 = SWIG_TMPOBJ ;
15561  PLFLT temp2 ;
15562  int res2 = SWIG_TMPOBJ ;
15563  PLINT temp3 ;
15564  int res3 = SWIG_TMPOBJ ;
15565  PLINT temp4 ;
15566  int res4 = SWIG_TMPOBJ ;
15567  PLINT temp5 ;
15568  int res5 = SWIG_TMPOBJ ;
15569  PLINT temp6 ;
15570  int res6 = SWIG_TMPOBJ ;
15571  octave_value_list _out;
15572  octave_value_list *_outp=&_out;
15573  octave_value _outv;
15574 
15575  arg1 = &temp1;
15576  arg2 = &temp2;
15577  arg3 = &temp3;
15578  arg4 = &temp4;
15579  arg5 = &temp5;
15580  arg6 = &temp6;
15581  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
15582  SWIG_fail;
15583  }
15584  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
15585  _outv = octave_value();
15586  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15587  if (SWIG_IsTmpObj(res1)) {
15588  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15589  } else {
15590  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15591  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15592  }
15593  if (SWIG_IsTmpObj(res2)) {
15594  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15595  } else {
15596  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15597  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15598  }
15599  if (SWIG_IsTmpObj(res3)) {
15600  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15601  } else {
15602  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15603  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15604  }
15605  if (SWIG_IsTmpObj(res4)) {
15606  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15607  } else {
15608  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15609  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15610  }
15611  if (SWIG_IsTmpObj(res5)) {
15612  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15613  } else {
15614  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15615  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15616  }
15617  if (SWIG_IsTmpObj(res6)) {
15618  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
15619  } else {
15620  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15621  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
15622  }
15623  return _out;
15624 fail:
15625  return octave_value_list();
15626 }
15627 
15628 
15629 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
15630  octave_value_list _out;
15631  octave_value_list *_outp=&_out;
15632  octave_value _outv;
15633 
15634  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
15635  SWIG_fail;
15636  }
15637  plgra();
15638  _outv = octave_value();
15639  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15640  return _out;
15641 fail:
15642  return octave_value_list();
15643 }
15644 
15645 
15646 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
15647  PLFLT *arg1 = (PLFLT *) 0 ;
15648  PLFLT *arg2 = (PLFLT *) 0 ;
15649  PLFLT *arg3 = (PLFLT *) 0 ;
15650  PLFLT *arg4 = (PLFLT *) 0 ;
15651  PLFLT temp1 ;
15652  int res1 = SWIG_TMPOBJ ;
15653  PLFLT temp2 ;
15654  int res2 = SWIG_TMPOBJ ;
15655  PLFLT temp3 ;
15656  int res3 = SWIG_TMPOBJ ;
15657  PLFLT temp4 ;
15658  int res4 = SWIG_TMPOBJ ;
15659  octave_value_list _out;
15660  octave_value_list *_outp=&_out;
15661  octave_value _outv;
15662 
15663  arg1 = &temp1;
15664  arg2 = &temp2;
15665  arg3 = &temp3;
15666  arg4 = &temp4;
15667  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
15668  SWIG_fail;
15669  }
15670  plgspa(arg1,arg2,arg3,arg4);
15671  _outv = octave_value();
15672  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15673  if (SWIG_IsTmpObj(res1)) {
15674  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15675  } else {
15676  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15677  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15678  }
15679  if (SWIG_IsTmpObj(res2)) {
15680  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15681  } else {
15682  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15683  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15684  }
15685  if (SWIG_IsTmpObj(res3)) {
15686  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15687  } else {
15688  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15689  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15690  }
15691  if (SWIG_IsTmpObj(res4)) {
15692  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15693  } else {
15694  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15695  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15696  }
15697  return _out;
15698 fail:
15699  return octave_value_list();
15700 }
15701 
15702 
15703 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
15704  PLINT *arg1 = (PLINT *) 0 ;
15705  PLINT temp1 ;
15706  int res1 = SWIG_TMPOBJ ;
15707  octave_value_list _out;
15708  octave_value_list *_outp=&_out;
15709  octave_value _outv;
15710 
15711  arg1 = &temp1;
15712  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
15713  SWIG_fail;
15714  }
15715  plgstrm(arg1);
15716  _outv = octave_value();
15717  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15718  if (SWIG_IsTmpObj(res1)) {
15719  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15720  } else {
15721  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15722  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15723  }
15724  return _out;
15725 fail:
15726  return octave_value_list();
15727 }
15728 
15729 
15730 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
15731  char *arg1 = (char *) 0 ;
15732  octave_value_list retval1 ;
15733  octave_value_list _out;
15734  octave_value_list *_outp=&_out;
15735  octave_value _outv;
15736 
15737  {
15738  // Check if version >= 3.4.0
15739 # if OCTAVE_API_VERSION_NUMBER < 45
15740  retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15741 # else
15742  retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15743 # endif
15744  arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15745  }
15746  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
15747  SWIG_fail;
15748  }
15749  plgver(arg1);
15750  _outv = octave_value();
15751  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15752  {
15753  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15754  }
15755  return _out;
15756 fail:
15757  return octave_value_list();
15758 }
15759 
15760 
15761 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
15762  PLFLT *arg1 = (PLFLT *) 0 ;
15763  PLFLT *arg2 = (PLFLT *) 0 ;
15764  PLFLT *arg3 = (PLFLT *) 0 ;
15765  PLFLT *arg4 = (PLFLT *) 0 ;
15766  PLFLT temp1 ;
15767  int res1 = SWIG_TMPOBJ ;
15768  PLFLT temp2 ;
15769  int res2 = SWIG_TMPOBJ ;
15770  PLFLT temp3 ;
15771  int res3 = SWIG_TMPOBJ ;
15772  PLFLT temp4 ;
15773  int res4 = SWIG_TMPOBJ ;
15774  octave_value_list _out;
15775  octave_value_list *_outp=&_out;
15776  octave_value _outv;
15777 
15778  arg1 = &temp1;
15779  arg2 = &temp2;
15780  arg3 = &temp3;
15781  arg4 = &temp4;
15782  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
15783  SWIG_fail;
15784  }
15785  plgvpd(arg1,arg2,arg3,arg4);
15786  _outv = octave_value();
15787  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15788  if (SWIG_IsTmpObj(res1)) {
15789  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15790  } else {
15791  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15792  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15793  }
15794  if (SWIG_IsTmpObj(res2)) {
15795  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15796  } else {
15797  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15798  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15799  }
15800  if (SWIG_IsTmpObj(res3)) {
15801  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15802  } else {
15803  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15804  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15805  }
15806  if (SWIG_IsTmpObj(res4)) {
15807  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15808  } else {
15809  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15810  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15811  }
15812  return _out;
15813 fail:
15814  return octave_value_list();
15815 }
15816 
15817 
15818 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
15819  PLFLT *arg1 = (PLFLT *) 0 ;
15820  PLFLT *arg2 = (PLFLT *) 0 ;
15821  PLFLT *arg3 = (PLFLT *) 0 ;
15822  PLFLT *arg4 = (PLFLT *) 0 ;
15823  PLFLT temp1 ;
15824  int res1 = SWIG_TMPOBJ ;
15825  PLFLT temp2 ;
15826  int res2 = SWIG_TMPOBJ ;
15827  PLFLT temp3 ;
15828  int res3 = SWIG_TMPOBJ ;
15829  PLFLT temp4 ;
15830  int res4 = SWIG_TMPOBJ ;
15831  octave_value_list _out;
15832  octave_value_list *_outp=&_out;
15833  octave_value _outv;
15834 
15835  arg1 = &temp1;
15836  arg2 = &temp2;
15837  arg3 = &temp3;
15838  arg4 = &temp4;
15839  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
15840  SWIG_fail;
15841  }
15842  plgvpw(arg1,arg2,arg3,arg4);
15843  _outv = octave_value();
15844  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15845  if (SWIG_IsTmpObj(res1)) {
15846  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15847  } else {
15848  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15849  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15850  }
15851  if (SWIG_IsTmpObj(res2)) {
15852  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15853  } else {
15854  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15855  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15856  }
15857  if (SWIG_IsTmpObj(res3)) {
15858  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15859  } else {
15860  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15861  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15862  }
15863  if (SWIG_IsTmpObj(res4)) {
15864  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15865  } else {
15866  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15867  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15868  }
15869  return _out;
15870 fail:
15871  return octave_value_list();
15872 }
15873 
15874 
15875 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
15876  PLINT *arg1 = (PLINT *) 0 ;
15877  PLINT *arg2 = (PLINT *) 0 ;
15878  PLINT temp1 ;
15879  int res1 = SWIG_TMPOBJ ;
15880  PLINT temp2 ;
15881  int res2 = SWIG_TMPOBJ ;
15882  octave_value_list _out;
15883  octave_value_list *_outp=&_out;
15884  octave_value _outv;
15885 
15886  arg1 = &temp1;
15887  arg2 = &temp2;
15888  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
15889  SWIG_fail;
15890  }
15891  plgxax(arg1,arg2);
15892  _outv = octave_value();
15893  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15894  if (SWIG_IsTmpObj(res1)) {
15895  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15896  } else {
15897  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15898  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15899  }
15900  if (SWIG_IsTmpObj(res2)) {
15901  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15902  } else {
15903  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15904  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15905  }
15906  return _out;
15907 fail:
15908  return octave_value_list();
15909 }
15910 
15911 
15912 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
15913  PLINT *arg1 = (PLINT *) 0 ;
15914  PLINT *arg2 = (PLINT *) 0 ;
15915  PLINT temp1 ;
15916  int res1 = SWIG_TMPOBJ ;
15917  PLINT temp2 ;
15918  int res2 = SWIG_TMPOBJ ;
15919  octave_value_list _out;
15920  octave_value_list *_outp=&_out;
15921  octave_value _outv;
15922 
15923  arg1 = &temp1;
15924  arg2 = &temp2;
15925  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
15926  SWIG_fail;
15927  }
15928  plgyax(arg1,arg2);
15929  _outv = octave_value();
15930  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15931  if (SWIG_IsTmpObj(res1)) {
15932  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15933  } else {
15934  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15935  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15936  }
15937  if (SWIG_IsTmpObj(res2)) {
15938  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15939  } else {
15940  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15941  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15942  }
15943  return _out;
15944 fail:
15945  return octave_value_list();
15946 }
15947 
15948 
15949 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
15950  PLINT *arg1 = (PLINT *) 0 ;
15951  PLINT *arg2 = (PLINT *) 0 ;
15952  PLINT temp1 ;
15953  int res1 = SWIG_TMPOBJ ;
15954  PLINT temp2 ;
15955  int res2 = SWIG_TMPOBJ ;
15956  octave_value_list _out;
15957  octave_value_list *_outp=&_out;
15958  octave_value _outv;
15959 
15960  arg1 = &temp1;
15961  arg2 = &temp2;
15962  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
15963  SWIG_fail;
15964  }
15965  plgzax(arg1,arg2);
15966  _outv = octave_value();
15967  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15968  if (SWIG_IsTmpObj(res1)) {
15969  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15970  } else {
15971  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15972  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15973  }
15974  if (SWIG_IsTmpObj(res2)) {
15975  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15976  } else {
15977  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15978  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15979  }
15980  return _out;
15981 fail:
15982  return octave_value_list();
15983 }
15984 
15985 
15986 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
15987  PLINT arg1 ;
15988  PLFLT *arg2 = (PLFLT *) 0 ;
15989  PLFLT arg3 ;
15990  PLFLT arg4 ;
15991  PLINT arg5 ;
15992  PLINT arg6 ;
15993  Matrix temp1 ;
15994  double val3 ;
15995  int ecode3 = 0 ;
15996  double val4 ;
15997  int ecode4 = 0 ;
15998  int val5 ;
15999  int ecode5 = 0 ;
16000  int val6 ;
16001  int ecode6 = 0 ;
16002  octave_value_list _out;
16003  octave_value_list *_outp=&_out;
16004  octave_value _outv;
16005 
16006  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
16007  SWIG_fail;
16008  }
16009  {
16010  if ( _n_dims( args(0) ) > 1 )
16011  {
16012  error( "argument must be a scalar or vector" ); SWIG_fail;
16013  }
16014  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16015  temp1 = args(0).matrix_value();
16016  arg2 = &temp1( 0, 0 );
16017  }
16018  ecode3 = SWIG_AsVal_double(args(1), &val3);
16019  if (!SWIG_IsOK(ecode3)) {
16020  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
16021  }
16022  arg3 = (PLFLT)(val3);
16023  ecode4 = SWIG_AsVal_double(args(2), &val4);
16024  if (!SWIG_IsOK(ecode4)) {
16025  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
16026  }
16027  arg4 = (PLFLT)(val4);
16028  ecode5 = SWIG_AsVal_int(args(3), &val5);
16029  if (!SWIG_IsOK(ecode5)) {
16030  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
16031  }
16032  arg5 = (PLINT)(val5);
16033  ecode6 = SWIG_AsVal_int(args(4), &val6);
16034  if (!SWIG_IsOK(ecode6)) {
16035  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
16036  }
16037  arg6 = (PLINT)(val6);
16038  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
16039  _outv = octave_value();
16040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16041  {
16042 
16043  }
16044  return _out;
16045 fail:
16046  {
16047 
16048  }
16049  return octave_value_list();
16050 }
16051 
16052 
16053 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
16054  PLFLT arg1 ;
16055  PLFLT arg2 ;
16056  PLFLT arg3 ;
16057  PLFLT *arg4 = (PLFLT *) 0 ;
16058  PLFLT *arg5 = (PLFLT *) 0 ;
16059  PLFLT *arg6 = (PLFLT *) 0 ;
16060  double val1 ;
16061  int ecode1 = 0 ;
16062  double val2 ;
16063  int ecode2 = 0 ;
16064  double val3 ;
16065  int ecode3 = 0 ;
16066  PLFLT temp4 ;
16067  int res4 = SWIG_TMPOBJ ;
16068  PLFLT temp5 ;
16069  int res5 = SWIG_TMPOBJ ;
16070  PLFLT temp6 ;
16071  int res6 = SWIG_TMPOBJ ;
16072  octave_value_list _out;
16073  octave_value_list *_outp=&_out;
16074  octave_value _outv;
16075 
16076  arg4 = &temp4;
16077  arg5 = &temp5;
16078  arg6 = &temp6;
16079  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
16080  SWIG_fail;
16081  }
16082  ecode1 = SWIG_AsVal_double(args(0), &val1);
16083  if (!SWIG_IsOK(ecode1)) {
16084  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
16085  }
16086  arg1 = (PLFLT)(val1);
16087  ecode2 = SWIG_AsVal_double(args(1), &val2);
16088  if (!SWIG_IsOK(ecode2)) {
16089  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
16090  }
16091  arg2 = (PLFLT)(val2);
16092  ecode3 = SWIG_AsVal_double(args(2), &val3);
16093  if (!SWIG_IsOK(ecode3)) {
16094  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
16095  }
16096  arg3 = (PLFLT)(val3);
16097  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
16098  _outv = octave_value();
16099  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16100  if (SWIG_IsTmpObj(res4)) {
16101  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16102  } else {
16103  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16104  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16105  }
16106  if (SWIG_IsTmpObj(res5)) {
16107  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
16108  } else {
16109  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16110  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
16111  }
16112  if (SWIG_IsTmpObj(res6)) {
16113  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
16114  } else {
16115  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16116  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
16117  }
16118  return _out;
16119 fail:
16120  return octave_value_list();
16121 }
16122 
16123 
16124 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
16125  octave_value_list _out;
16126  octave_value_list *_outp=&_out;
16127  octave_value _outv;
16128 
16129  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
16130  SWIG_fail;
16131  }
16132  plinit();
16133  _outv = octave_value();
16134  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16135  return _out;
16136 fail:
16137  return octave_value_list();
16138 }
16139 
16140 
16141 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
16142  PLFLT arg1 ;
16143  PLFLT arg2 ;
16144  PLFLT arg3 ;
16145  PLFLT arg4 ;
16146  double val1 ;
16147  int ecode1 = 0 ;
16148  double val2 ;
16149  int ecode2 = 0 ;
16150  double val3 ;
16151  int ecode3 = 0 ;
16152  double val4 ;
16153  int ecode4 = 0 ;
16154  octave_value_list _out;
16155  octave_value_list *_outp=&_out;
16156  octave_value _outv;
16157 
16158  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
16159  SWIG_fail;
16160  }
16161  ecode1 = SWIG_AsVal_double(args(0), &val1);
16162  if (!SWIG_IsOK(ecode1)) {
16163  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
16164  }
16165  arg1 = (PLFLT)(val1);
16166  ecode2 = SWIG_AsVal_double(args(1), &val2);
16167  if (!SWIG_IsOK(ecode2)) {
16168  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
16169  }
16170  arg2 = (PLFLT)(val2);
16171  ecode3 = SWIG_AsVal_double(args(2), &val3);
16172  if (!SWIG_IsOK(ecode3)) {
16173  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
16174  }
16175  arg3 = (PLFLT)(val3);
16176  ecode4 = SWIG_AsVal_double(args(3), &val4);
16177  if (!SWIG_IsOK(ecode4)) {
16178  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
16179  }
16180  arg4 = (PLFLT)(val4);
16181  pljoin(arg1,arg2,arg3,arg4);
16182  _outv = octave_value();
16183  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16184  return _out;
16185 fail:
16186  return octave_value_list();
16187 }
16188 
16189 
16190 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
16191  char *arg1 = (char *) 0 ;
16192  char *arg2 = (char *) 0 ;
16193  char *arg3 = (char *) 0 ;
16194  int res1 ;
16195  char *buf1 = 0 ;
16196  int alloc1 = 0 ;
16197  int res2 ;
16198  char *buf2 = 0 ;
16199  int alloc2 = 0 ;
16200  int res3 ;
16201  char *buf3 = 0 ;
16202  int alloc3 = 0 ;
16203  octave_value_list _out;
16204  octave_value_list *_outp=&_out;
16205  octave_value _outv;
16206 
16207  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
16208  SWIG_fail;
16209  }
16210  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16211  if (!SWIG_IsOK(res1)) {
16212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
16213  }
16214  arg1 = (char *)(buf1);
16215  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
16216  if (!SWIG_IsOK(res2)) {
16217  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
16218  }
16219  arg2 = (char *)(buf2);
16220  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
16221  if (!SWIG_IsOK(res3)) {
16222  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
16223  }
16224  arg3 = (char *)(buf3);
16225  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
16226  _outv = octave_value();
16227  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16228  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16229  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16230  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16231  return _out;
16232 fail:
16233  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16234  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16235  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16236  return octave_value_list();
16237 }
16238 
16239 
16240 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
16241  PLFLT *arg1 = (PLFLT *) 0 ;
16242  PLFLT *arg2 = (PLFLT *) 0 ;
16243  PLINT arg3 ;
16244  PLINT arg4 ;
16245  PLFLT arg5 ;
16246  PLFLT arg6 ;
16247  PLFLT arg7 ;
16248  PLINT arg8 ;
16249  PLINT arg9 ;
16250  PLINT arg10 ;
16251  PLINT arg11 ;
16252  PLINT arg12 ;
16253  PLINT arg13 ;
16254  PLINT *arg14 = (PLINT *) 0 ;
16255  PLFLT arg15 ;
16256  PLFLT arg16 ;
16257  PLFLT arg17 ;
16258  PLFLT arg18 ;
16259  PLINT *arg19 = (PLINT *) 0 ;
16260  char **arg20 = (char **) 0 ;
16261  PLINT *arg21 = (PLINT *) 0 ;
16262  PLINT *arg22 = (PLINT *) 0 ;
16263  PLFLT *arg23 = (PLFLT *) 0 ;
16264  PLFLT *arg24 = (PLFLT *) 0 ;
16265  PLINT *arg25 = (PLINT *) 0 ;
16266  PLINT *arg26 = (PLINT *) 0 ;
16267  PLFLT *arg27 = (PLFLT *) 0 ;
16268  PLINT *arg28 = (PLINT *) 0 ;
16269  PLFLT *arg29 = (PLFLT *) 0 ;
16270  PLINT *arg30 = (PLINT *) 0 ;
16271  char **arg31 = (char **) 0 ;
16272  PLFLT temp1 ;
16273  int res1 = SWIG_TMPOBJ ;
16274  PLFLT temp2 ;
16275  int res2 = SWIG_TMPOBJ ;
16276  int val3 ;
16277  int ecode3 = 0 ;
16278  int val4 ;
16279  int ecode4 = 0 ;
16280  double val5 ;
16281  int ecode5 = 0 ;
16282  double val6 ;
16283  int ecode6 = 0 ;
16284  double val7 ;
16285  int ecode7 = 0 ;
16286  int val8 ;
16287  int ecode8 = 0 ;
16288  int val9 ;
16289  int ecode9 = 0 ;
16290  int val10 ;
16291  int ecode10 = 0 ;
16292  int val11 ;
16293  int ecode11 = 0 ;
16294  int val12 ;
16295  int ecode12 = 0 ;
16296  Matrix temp13 ;
16297  double val15 ;
16298  int ecode15 = 0 ;
16299  double val16 ;
16300  int ecode16 = 0 ;
16301  double val17 ;
16302  int ecode17 = 0 ;
16303  double val18 ;
16304  int ecode18 = 0 ;
16305  Matrix temp19 ;
16306  Matrix temp21 ;
16307  Matrix temp22 ;
16308  Matrix temp23 ;
16309  Matrix temp24 ;
16310  Matrix temp25 ;
16311  Matrix temp26 ;
16312  Matrix temp27 ;
16313  Matrix temp28 ;
16314  Matrix temp29 ;
16315  Matrix temp30 ;
16316  octave_value_list _out;
16317  octave_value_list *_outp=&_out;
16318  octave_value _outv;
16319 
16320  arg1 = &temp1;
16321  arg2 = &temp2;
16322  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
16323  SWIG_fail;
16324  }
16325  ecode3 = SWIG_AsVal_int(args(0), &val3);
16326  if (!SWIG_IsOK(ecode3)) {
16327  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
16328  }
16329  arg3 = (PLINT)(val3);
16330  ecode4 = SWIG_AsVal_int(args(1), &val4);
16331  if (!SWIG_IsOK(ecode4)) {
16332  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
16333  }
16334  arg4 = (PLINT)(val4);
16335  ecode5 = SWIG_AsVal_double(args(2), &val5);
16336  if (!SWIG_IsOK(ecode5)) {
16337  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
16338  }
16339  arg5 = (PLFLT)(val5);
16340  ecode6 = SWIG_AsVal_double(args(3), &val6);
16341  if (!SWIG_IsOK(ecode6)) {
16342  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
16343  }
16344  arg6 = (PLFLT)(val6);
16345  ecode7 = SWIG_AsVal_double(args(4), &val7);
16346  if (!SWIG_IsOK(ecode7)) {
16347  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
16348  }
16349  arg7 = (PLFLT)(val7);
16350  ecode8 = SWIG_AsVal_int(args(5), &val8);
16351  if (!SWIG_IsOK(ecode8)) {
16352  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
16353  }
16354  arg8 = (PLINT)(val8);
16355  ecode9 = SWIG_AsVal_int(args(6), &val9);
16356  if (!SWIG_IsOK(ecode9)) {
16357  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
16358  }
16359  arg9 = (PLINT)(val9);
16360  ecode10 = SWIG_AsVal_int(args(7), &val10);
16361  if (!SWIG_IsOK(ecode10)) {
16362  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
16363  }
16364  arg10 = (PLINT)(val10);
16365  ecode11 = SWIG_AsVal_int(args(8), &val11);
16366  if (!SWIG_IsOK(ecode11)) {
16367  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
16368  }
16369  arg11 = (PLINT)(val11);
16370  ecode12 = SWIG_AsVal_int(args(9), &val12);
16371  if (!SWIG_IsOK(ecode12)) {
16372  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
16373  }
16374  arg12 = (PLINT)(val12);
16375  {
16376  if ( _n_dims( args(10) ) > 1 )
16377  {
16378  error( "argument must be a scalar or vector" ); SWIG_fail;
16379  }
16380  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
16381  arg14 = new PLINT[Alen];
16382  temp13 = args(10).matrix_value();
16383  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
16384  }
16385  ecode15 = SWIG_AsVal_double(args(11), &val15);
16386  if (!SWIG_IsOK(ecode15)) {
16387  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
16388  }
16389  arg15 = (PLFLT)(val15);
16390  ecode16 = SWIG_AsVal_double(args(12), &val16);
16391  if (!SWIG_IsOK(ecode16)) {
16392  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
16393  }
16394  arg16 = (PLFLT)(val16);
16395  ecode17 = SWIG_AsVal_double(args(13), &val17);
16396  if (!SWIG_IsOK(ecode17)) {
16397  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
16398  }
16399  arg17 = (PLFLT)(val17);
16400  ecode18 = SWIG_AsVal_double(args(14), &val18);
16401  if (!SWIG_IsOK(ecode18)) {
16402  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
16403  }
16404  arg18 = (PLFLT)(val18);
16405  {
16406  if ( _n_dims( args(15) ) > 1 )
16407  {
16408  error( "argument must be a scalar or vector" ); SWIG_fail;
16409  }
16410  if ( _dim( args(15), 0 ) != Alen )
16411  {
16412  error( "argument vectors must be same length" ); SWIG_fail;
16413  }
16414  temp19 = args(15).matrix_value();
16415  arg19 = new PLINT[Alen];
16416  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
16417  }
16418  {
16419  charMatrix temp_matrix;
16420  Cell temp_cell;
16421  char *tmp_cstring;
16422  std::string str;
16423  size_t max_length, non_blank_length;
16424  int i, ifcell;
16425  if ( _n_dims( args(16) ) > 2 )
16426  {
16427  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16428  }
16429  if ( !args(16).is_empty() )
16430  {
16431  if ( _dim( args(16), 0 ) != Alen )
16432  {
16433  error( "first dimension must be same length as previous vector" ); SWIG_fail;
16434  }
16435  arg20 = new char*[Alen];
16436  ifcell = args(16).is_cell();
16437  if ( ifcell )
16438  {
16439  temp_cell = args(16).cell_value();
16440  }
16441  else
16442  {
16443  temp_matrix = args(16).char_matrix_value();
16444  // Allow one extra space for null termination.
16445  max_length = _dim( args(16), 1 ) + 1;
16446  }
16447 
16448  for ( i = 0; i < Alen; i++ )
16449  {
16450  // Must copy string to "permanent" location because the string
16451  // location corresponding to tmp_cstring gets
16452  // overwritten for each iteration of loop.
16453  if ( ifcell )
16454  {
16455  if ( temp_cell.elem( i ).is_string() )
16456  {
16457  str = temp_cell.elem( i ).string_value();
16458  // leave room for null termination.
16459  max_length = str.size() + 1;
16460  tmp_cstring = (char *) str.c_str();
16461  }
16462  else
16463  {
16464  // Use null string if user attempts to pass a cell array
16465  // with a non-string element (likely an empty element
16466  // since that should be allowed by the PLplot interface
16467  // if that element is going to be unused).
16468  // leave room for null termination.
16469  max_length = 1;
16470  tmp_cstring = (char *) "";
16471  }
16472  }
16473  else
16474  {
16475  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16476  }
16477  arg20[i] = new char[max_length];
16478  strncpy( arg20[i], tmp_cstring, max_length - 1 );
16479  arg20[i][max_length - 1] = '\0';
16480  // All the trailing blank crapola should not be needed for
16481  // string cell arrays.
16482  if ( !ifcell )
16483  {
16484  // remove trailing-blank padding that is used by the
16485  // charMatrix class to insure all strings in a given
16486  // charMatrix instance have the same length.
16487  // This transformation also removes legitimate trailing
16488  // blanks but there is nothing we can do about that
16489  // for the charMatrix class.
16490 
16491  // Look for trailing nulls first (just in case, although that
16492  // shouldn't happen if charMatrix implemented as documented)
16493  // before looking for trailing blanks.
16494  non_blank_length = max_length - 2;
16495  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16496  {
16497  non_blank_length--;
16498  }
16499  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16500  {
16501  non_blank_length--;
16502  }
16503  arg20[i][non_blank_length + 1] = '\0';
16504  }
16505  }
16506  }
16507  else
16508  {
16509  arg20 = NULL;
16510  }
16511  }
16512  {
16513  if ( _n_dims( args(17) ) > 1 )
16514  {
16515  error( "argument must be a scalar or vector" ); SWIG_fail;
16516  }
16517  if ( !args(17).is_empty() )
16518  {
16519  if ( _dim( args(17), 0 ) != Alen )
16520  {
16521  error( "argument vectors must be same length" ); SWIG_fail;
16522  }
16523  temp21 = args(17).matrix_value();
16524  arg21 = new PLINT[Alen];
16525  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
16526  }
16527  else
16528  {
16529  arg21 = NULL;
16530  }
16531  }
16532  {
16533  if ( _n_dims( args(18) ) > 1 )
16534  {
16535  error( "argument must be a scalar or vector" ); SWIG_fail;
16536  }
16537  if ( !args(18).is_empty() )
16538  {
16539  if ( _dim( args(18), 0 ) != Alen )
16540  {
16541  error( "argument vectors must be same length" ); SWIG_fail;
16542  }
16543  temp22 = args(18).matrix_value();
16544  arg22 = new PLINT[Alen];
16545  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16546  }
16547  else
16548  {
16549  arg22 = NULL;
16550  }
16551  }
16552  {
16553  if ( _n_dims( args(19) ) > 1 )
16554  {
16555  error( "argument must be a scalar or vector" ); SWIG_fail;
16556  }
16557  if ( !args(19).is_empty() )
16558  {
16559  if ( _dim( args(19), 0 ) != Alen )
16560  {
16561  error( "argument vectors must be same length" ); SWIG_fail;
16562  }
16563  temp23 = args(19).matrix_value();
16564  arg23 = &temp23( 0, 0 );
16565  }
16566  else
16567  {
16568  arg23 = NULL;
16569  }
16570  }
16571  {
16572  if ( _n_dims( args(20) ) > 1 )
16573  {
16574  error( "argument must be a scalar or vector" ); SWIG_fail;
16575  }
16576  if ( !args(20).is_empty() )
16577  {
16578  if ( _dim( args(20), 0 ) != Alen )
16579  {
16580  error( "argument vectors must be same length" ); SWIG_fail;
16581  }
16582  temp24 = args(20).matrix_value();
16583  arg24 = &temp24( 0, 0 );
16584  }
16585  else
16586  {
16587  arg24 = NULL;
16588  }
16589  }
16590  {
16591  if ( _n_dims( args(21) ) > 1 )
16592  {
16593  error( "argument must be a scalar or vector" ); SWIG_fail;
16594  }
16595  if ( !args(21).is_empty() )
16596  {
16597  if ( _dim( args(21), 0 ) != Alen )
16598  {
16599  error( "argument vectors must be same length" ); SWIG_fail;
16600  }
16601  temp25 = args(21).matrix_value();
16602  arg25 = new PLINT[Alen];
16603  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
16604  }
16605  else
16606  {
16607  arg25 = NULL;
16608  }
16609  }
16610  {
16611  if ( _n_dims( args(22) ) > 1 )
16612  {
16613  error( "argument must be a scalar or vector" ); SWIG_fail;
16614  }
16615  if ( !args(22).is_empty() )
16616  {
16617  if ( _dim( args(22), 0 ) != Alen )
16618  {
16619  error( "argument vectors must be same length" ); SWIG_fail;
16620  }
16621  temp26 = args(22).matrix_value();
16622  arg26 = new PLINT[Alen];
16623  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
16624  }
16625  else
16626  {
16627  arg26 = NULL;
16628  }
16629  }
16630  {
16631  if ( _n_dims( args(23) ) > 1 )
16632  {
16633  error( "argument must be a scalar or vector" ); SWIG_fail;
16634  }
16635  if ( !args(23).is_empty() )
16636  {
16637  if ( _dim( args(23), 0 ) != Alen )
16638  {
16639  error( "argument vectors must be same length" ); SWIG_fail;
16640  }
16641  temp27 = args(23).matrix_value();
16642  arg27 = &temp27( 0, 0 );
16643  }
16644  else
16645  {
16646  arg27 = NULL;
16647  }
16648  }
16649  {
16650  if ( _n_dims( args(24) ) > 1 )
16651  {
16652  error( "argument must be a scalar or vector" ); SWIG_fail;
16653  }
16654  if ( !args(24).is_empty() )
16655  {
16656  if ( _dim( args(24), 0 ) != Alen )
16657  {
16658  error( "argument vectors must be same length" ); SWIG_fail;
16659  }
16660  temp28 = args(24).matrix_value();
16661  arg28 = new PLINT[Alen];
16662  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
16663  }
16664  else
16665  {
16666  arg28 = NULL;
16667  }
16668  }
16669  {
16670  if ( _n_dims( args(25) ) > 1 )
16671  {
16672  error( "argument must be a scalar or vector" ); SWIG_fail;
16673  }
16674  if ( !args(25).is_empty() )
16675  {
16676  if ( _dim( args(25), 0 ) != Alen )
16677  {
16678  error( "argument vectors must be same length" ); SWIG_fail;
16679  }
16680  temp29 = args(25).matrix_value();
16681  arg29 = &temp29( 0, 0 );
16682  }
16683  else
16684  {
16685  arg29 = NULL;
16686  }
16687  }
16688  {
16689  if ( _n_dims( args(26) ) > 1 )
16690  {
16691  error( "argument must be a scalar or vector" ); SWIG_fail;
16692  }
16693  if ( !args(26).is_empty() )
16694  {
16695  if ( _dim( args(26), 0 ) != Alen )
16696  {
16697  error( "argument vectors must be same length" ); SWIG_fail;
16698  }
16699  temp30 = args(26).matrix_value();
16700  arg30 = new PLINT[Alen];
16701  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
16702  }
16703  else
16704  {
16705  arg30 = NULL;
16706  }
16707  }
16708  {
16709  charMatrix temp_matrix;
16710  Cell temp_cell;
16711  char *tmp_cstring;
16712  std::string str;
16713  size_t max_length, non_blank_length;
16714  int i, ifcell;
16715  if ( _n_dims( args(27) ) > 2 )
16716  {
16717  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16718  }
16719  if ( !args(27).is_empty() )
16720  {
16721  if ( _dim( args(27), 0 ) != Alen )
16722  {
16723  error( "first dimension must be same length as previous vector" ); SWIG_fail;
16724  }
16725  arg31 = new char*[Alen];
16726  ifcell = args(27).is_cell();
16727  if ( ifcell )
16728  {
16729  temp_cell = args(27).cell_value();
16730  }
16731  else
16732  {
16733  temp_matrix = args(27).char_matrix_value();
16734  // Allow one extra space for null termination.
16735  max_length = _dim( args(27), 1 ) + 1;
16736  }
16737 
16738  for ( i = 0; i < Alen; i++ )
16739  {
16740  // Must copy string to "permanent" location because the string
16741  // location corresponding to tmp_cstring gets
16742  // overwritten for each iteration of loop.
16743  if ( ifcell )
16744  {
16745  if ( temp_cell.elem( i ).is_string() )
16746  {
16747  str = temp_cell.elem( i ).string_value();
16748  // leave room for null termination.
16749  max_length = str.size() + 1;
16750  tmp_cstring = (char *) str.c_str();
16751  }
16752  else
16753  {
16754  // Use null string if user attempts to pass a cell array
16755  // with a non-string element (likely an empty element
16756  // since that should be allowed by the PLplot interface
16757  // if that element is going to be unused).
16758  // leave room for null termination.
16759  max_length = 1;
16760  tmp_cstring = (char *) "";
16761  }
16762  }
16763  else
16764  {
16765  tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16766  }
16767  arg31[i] = new char[max_length];
16768  strncpy( arg31[i], tmp_cstring, max_length - 1 );
16769  arg31[i][max_length - 1] = '\0';
16770  // All the trailing blank crapola should not be needed for
16771  // string cell arrays.
16772  if ( !ifcell )
16773  {
16774  // remove trailing-blank padding that is used by the
16775  // charMatrix class to insure all strings in a given
16776  // charMatrix instance have the same length.
16777  // This transformation also removes legitimate trailing
16778  // blanks but there is nothing we can do about that
16779  // for the charMatrix class.
16780 
16781  // Look for trailing nulls first (just in case, although that
16782  // shouldn't happen if charMatrix implemented as documented)
16783  // before looking for trailing blanks.
16784  non_blank_length = max_length - 2;
16785  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
16786  {
16787  non_blank_length--;
16788  }
16789  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
16790  {
16791  non_blank_length--;
16792  }
16793  arg31[i][non_blank_length + 1] = '\0';
16794  }
16795  }
16796  }
16797  else
16798  {
16799  arg31 = NULL;
16800  }
16801  }
16802  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);
16803  _outv = octave_value();
16804  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16805  if (SWIG_IsTmpObj(res1)) {
16806  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16807  } else {
16808  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16809  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16810  }
16811  if (SWIG_IsTmpObj(res2)) {
16812  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16813  } else {
16814  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16815  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16816  }
16817  {
16818  delete [] arg14;
16819  }
16820  {
16821  delete [] arg19;
16822  }
16823  {
16824  int i;
16825  if ( arg20 != NULL )
16826  {
16827  for ( i = 0; i < Alen; i++ )
16828  {
16829  delete[] arg20[i];
16830  }
16831  delete[] arg20;
16832  }
16833  }
16834  {
16835  if ( arg21 != NULL )
16836  delete [] arg21;
16837  }
16838  {
16839  if ( arg22 != NULL )
16840  delete [] arg22;
16841  }
16842  {
16843 
16844  }
16845  {
16846 
16847  }
16848  {
16849  if ( arg25 != NULL )
16850  delete [] arg25;
16851  }
16852  {
16853  if ( arg26 != NULL )
16854  delete [] arg26;
16855  }
16856  {
16857 
16858  }
16859  {
16860  if ( arg28 != NULL )
16861  delete [] arg28;
16862  }
16863  {
16864 
16865  }
16866  {
16867  if ( arg30 != NULL )
16868  delete [] arg30;
16869  }
16870  {
16871  int i;
16872  if ( arg31 != NULL )
16873  {
16874  for ( i = 0; i < Alen; i++ )
16875  {
16876  delete[] arg31[i];
16877  }
16878  delete[] arg31;
16879  }
16880  }
16881  return _out;
16882 fail:
16883  {
16884  delete [] arg14;
16885  }
16886  {
16887  delete [] arg19;
16888  }
16889  {
16890  int i;
16891  if ( arg20 != NULL )
16892  {
16893  for ( i = 0; i < Alen; i++ )
16894  {
16895  delete[] arg20[i];
16896  }
16897  delete[] arg20;
16898  }
16899  }
16900  {
16901  if ( arg21 != NULL )
16902  delete [] arg21;
16903  }
16904  {
16905  if ( arg22 != NULL )
16906  delete [] arg22;
16907  }
16908  {
16909 
16910  }
16911  {
16912 
16913  }
16914  {
16915  if ( arg25 != NULL )
16916  delete [] arg25;
16917  }
16918  {
16919  if ( arg26 != NULL )
16920  delete [] arg26;
16921  }
16922  {
16923 
16924  }
16925  {
16926  if ( arg28 != NULL )
16927  delete [] arg28;
16928  }
16929  {
16930 
16931  }
16932  {
16933  if ( arg30 != NULL )
16934  delete [] arg30;
16935  }
16936  {
16937  int i;
16938  if ( arg31 != NULL )
16939  {
16940  for ( i = 0; i < Alen; i++ )
16941  {
16942  delete[] arg31[i];
16943  }
16944  delete[] arg31;
16945  }
16946  }
16947  return octave_value_list();
16948 }
16949 
16950 
16951 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
16952  PLFLT arg1 ;
16953  PLFLT arg2 ;
16954  PLFLT arg3 ;
16955  double val1 ;
16956  int ecode1 = 0 ;
16957  double val2 ;
16958  int ecode2 = 0 ;
16959  double val3 ;
16960  int ecode3 = 0 ;
16961  octave_value_list _out;
16962  octave_value_list *_outp=&_out;
16963  octave_value _outv;
16964 
16965  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
16966  SWIG_fail;
16967  }
16968  ecode1 = SWIG_AsVal_double(args(0), &val1);
16969  if (!SWIG_IsOK(ecode1)) {
16970  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
16971  }
16972  arg1 = (PLFLT)(val1);
16973  ecode2 = SWIG_AsVal_double(args(1), &val2);
16974  if (!SWIG_IsOK(ecode2)) {
16975  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
16976  }
16977  arg2 = (PLFLT)(val2);
16978  ecode3 = SWIG_AsVal_double(args(2), &val3);
16979  if (!SWIG_IsOK(ecode3)) {
16980  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
16981  }
16982  arg3 = (PLFLT)(val3);
16983  pllightsource(arg1,arg2,arg3);
16984  _outv = octave_value();
16985  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16986  return _out;
16987 fail:
16988  return octave_value_list();
16989 }
16990 
16991 
16992 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
16993  PLINT arg1 ;
16994  PLFLT *arg2 = (PLFLT *) 0 ;
16995  PLFLT *arg3 = (PLFLT *) 0 ;
16996  Matrix temp1 ;
16997  Matrix temp3 ;
16998  octave_value_list _out;
16999  octave_value_list *_outp=&_out;
17000  octave_value _outv;
17001 
17002  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
17003  SWIG_fail;
17004  }
17005  {
17006  if ( _n_dims( args(0) ) > 1 )
17007  {
17008  error( "argument must be a scalar or vector" ); SWIG_fail;
17009  }
17010  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17011  temp1 = args(0).matrix_value();
17012  arg2 = &temp1( 0, 0 );
17013  }
17014  {
17015  if ( _n_dims( args(1) ) > 1 )
17016  {
17017  error( "argument must be a scalar or vector" ); SWIG_fail;
17018  }
17019  if ( _dim( args(1), 0 ) != Alen )
17020  {
17021  error( "argument vectors must be same length" ); SWIG_fail;
17022  }
17023  temp3 = args(1).matrix_value();
17024  arg3 = &temp3( 0, 0 );
17025  }
17026  plline(arg1,(double const *)arg2,(double const *)arg3);
17027  _outv = octave_value();
17028  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17029  {
17030 
17031  }
17032  {
17033 
17034  }
17035  return _out;
17036 fail:
17037  {
17038 
17039  }
17040  {
17041 
17042  }
17043  return octave_value_list();
17044 }
17045 
17046 
17047 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
17048  PLINT arg1 ;
17049  PLFLT *arg2 = (PLFLT *) 0 ;
17050  PLFLT *arg3 = (PLFLT *) 0 ;
17051  PLFLT *arg4 = (PLFLT *) 0 ;
17052  Matrix temp1 ;
17053  Matrix temp3 ;
17054  Matrix temp4 ;
17055  octave_value_list _out;
17056  octave_value_list *_outp=&_out;
17057  octave_value _outv;
17058 
17059  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
17060  SWIG_fail;
17061  }
17062  {
17063  if ( _n_dims( args(0) ) > 1 )
17064  {
17065  error( "argument must be a scalar or vector" ); SWIG_fail;
17066  }
17067  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17068  temp1 = args(0).matrix_value();
17069  arg2 = &temp1( 0, 0 );
17070  }
17071  {
17072  if ( _n_dims( args(1) ) > 1 )
17073  {
17074  error( "argument must be a scalar or vector" ); SWIG_fail;
17075  }
17076  if ( _dim( args(1), 0 ) != Alen )
17077  {
17078  error( "argument vectors must be same length" ); SWIG_fail;
17079  }
17080  temp3 = args(1).matrix_value();
17081  arg3 = &temp3( 0, 0 );
17082  }
17083  {
17084  if ( _n_dims( args(2) ) > 1 )
17085  {
17086  error( "argument must be a scalar or vector" ); SWIG_fail;
17087  }
17088  if ( _dim( args(2), 0 ) != Alen )
17089  {
17090  error( "argument vectors must be same length" ); SWIG_fail;
17091  }
17092  temp4 = args(2).matrix_value();
17093  arg4 = &temp4( 0, 0 );
17094  }
17095  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17096  _outv = octave_value();
17097  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17098  {
17099 
17100  }
17101  {
17102 
17103  }
17104  {
17105 
17106  }
17107  return _out;
17108 fail:
17109  {
17110 
17111  }
17112  {
17113 
17114  }
17115  {
17116 
17117  }
17118  return octave_value_list();
17119 }
17120 
17121 
17122 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
17123  PLINT arg1 ;
17124  int val1 ;
17125  int ecode1 = 0 ;
17126  octave_value_list _out;
17127  octave_value_list *_outp=&_out;
17128  octave_value _outv;
17129 
17130  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
17131  SWIG_fail;
17132  }
17133  ecode1 = SWIG_AsVal_int(args(0), &val1);
17134  if (!SWIG_IsOK(ecode1)) {
17135  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
17136  }
17137  arg1 = (PLINT)(val1);
17138  pllsty(arg1);
17139  _outv = octave_value();
17140  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17141  return _out;
17142 fail:
17143  return octave_value_list();
17144 }
17145 
17146 
17147 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
17148  PLINT *arg1 = (PLINT *) 0 ;
17149  PLINT temp1 ;
17150  int res1 = SWIG_TMPOBJ ;
17151  octave_value_list _out;
17152  octave_value_list *_outp=&_out;
17153  octave_value _outv;
17154 
17155  arg1 = &temp1;
17156  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
17157  SWIG_fail;
17158  }
17159  plmkstrm(arg1);
17160  _outv = octave_value();
17161  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17162  if (SWIG_IsTmpObj(res1)) {
17163  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17164  } else {
17165  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17166  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17167  }
17168  return _out;
17169 fail:
17170  return octave_value_list();
17171 }
17172 
17173 
17174 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
17175  char *arg1 = (char *) 0 ;
17176  PLFLT arg2 ;
17177  PLFLT arg3 ;
17178  PLFLT arg4 ;
17179  char *arg5 = (char *) 0 ;
17180  int res1 ;
17181  char *buf1 = 0 ;
17182  int alloc1 = 0 ;
17183  double val2 ;
17184  int ecode2 = 0 ;
17185  double val3 ;
17186  int ecode3 = 0 ;
17187  double val4 ;
17188  int ecode4 = 0 ;
17189  int res5 ;
17190  char *buf5 = 0 ;
17191  int alloc5 = 0 ;
17192  octave_value_list _out;
17193  octave_value_list *_outp=&_out;
17194  octave_value _outv;
17195 
17196  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
17197  SWIG_fail;
17198  }
17199  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17200  if (!SWIG_IsOK(res1)) {
17201  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
17202  }
17203  arg1 = (char *)(buf1);
17204  ecode2 = SWIG_AsVal_double(args(1), &val2);
17205  if (!SWIG_IsOK(ecode2)) {
17206  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
17207  }
17208  arg2 = (PLFLT)(val2);
17209  ecode3 = SWIG_AsVal_double(args(2), &val3);
17210  if (!SWIG_IsOK(ecode3)) {
17211  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
17212  }
17213  arg3 = (PLFLT)(val3);
17214  ecode4 = SWIG_AsVal_double(args(3), &val4);
17215  if (!SWIG_IsOK(ecode4)) {
17216  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
17217  }
17218  arg4 = (PLFLT)(val4);
17219  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17220  if (!SWIG_IsOK(res5)) {
17221  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
17222  }
17223  arg5 = (char *)(buf5);
17224  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
17225  _outv = octave_value();
17226  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17227  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17228  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17229  return _out;
17230 fail:
17231  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17232  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17233  return octave_value_list();
17234 }
17235 
17236 
17237 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
17238  char *arg1 = (char *) 0 ;
17239  PLFLT arg2 ;
17240  PLFLT arg3 ;
17241  PLFLT arg4 ;
17242  char *arg5 = (char *) 0 ;
17243  int res1 ;
17244  char *buf1 = 0 ;
17245  int alloc1 = 0 ;
17246  double val2 ;
17247  int ecode2 = 0 ;
17248  double val3 ;
17249  int ecode3 = 0 ;
17250  double val4 ;
17251  int ecode4 = 0 ;
17252  int res5 ;
17253  char *buf5 = 0 ;
17254  int alloc5 = 0 ;
17255  octave_value_list _out;
17256  octave_value_list *_outp=&_out;
17257  octave_value _outv;
17258 
17259  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
17260  SWIG_fail;
17261  }
17262  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17263  if (!SWIG_IsOK(res1)) {
17264  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
17265  }
17266  arg1 = (char *)(buf1);
17267  ecode2 = SWIG_AsVal_double(args(1), &val2);
17268  if (!SWIG_IsOK(ecode2)) {
17269  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
17270  }
17271  arg2 = (PLFLT)(val2);
17272  ecode3 = SWIG_AsVal_double(args(2), &val3);
17273  if (!SWIG_IsOK(ecode3)) {
17274  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
17275  }
17276  arg3 = (PLFLT)(val3);
17277  ecode4 = SWIG_AsVal_double(args(3), &val4);
17278  if (!SWIG_IsOK(ecode4)) {
17279  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
17280  }
17281  arg4 = (PLFLT)(val4);
17282  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17283  if (!SWIG_IsOK(res5)) {
17284  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
17285  }
17286  arg5 = (char *)(buf5);
17287  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
17288  _outv = octave_value();
17289  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17290  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17291  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17292  return _out;
17293 fail:
17294  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17295  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17296  return octave_value_list();
17297 }
17298 
17299 
17300 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
17301  int *arg1 = (int *) 0 ;
17302  char **arg2 = (char **) 0 ;
17303  PLINT arg3 ;
17304  void *argp1 = 0 ;
17305  int res1 = 0 ;
17306  void *argp2 = 0 ;
17307  int res2 = 0 ;
17308  int val3 ;
17309  int ecode3 = 0 ;
17310  octave_value_list _out;
17311  octave_value_list *_outp=&_out;
17312  octave_value _outv;
17313  PLINT result;
17314 
17315  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
17316  SWIG_fail;
17317  }
17318  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
17319  if (!SWIG_IsOK(res1)) {
17320  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
17321  }
17322  arg1 = (int *)(argp1);
17323  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
17324  if (!SWIG_IsOK(res2)) {
17325  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char const **""'");
17326  }
17327  arg2 = (char **)(argp2);
17328  ecode3 = SWIG_AsVal_int(args(2), &val3);
17329  if (!SWIG_IsOK(ecode3)) {
17330  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
17331  }
17332  arg3 = (PLINT)(val3);
17333  result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
17334  _outv = SWIG_From_int((int)(result));
17335  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17336  return _out;
17337 fail:
17338  return octave_value_list();
17339 }
17340 
17341 
17342 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
17343  PLINT arg1 ;
17344  PLINT *arg2 = (PLINT *) 0 ;
17345  PLINT *arg3 = (PLINT *) 0 ;
17346  Matrix temp1 ;
17347  Matrix temp3 ;
17348  octave_value_list _out;
17349  octave_value_list *_outp=&_out;
17350  octave_value _outv;
17351 
17352  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
17353  SWIG_fail;
17354  }
17355  {
17356  if ( _n_dims( args(0) ) > 1 )
17357  {
17358  error( "argument must be a scalar or vector" ); SWIG_fail;
17359  }
17360  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17361  arg2 = new PLINT[Alen];
17362  temp1 = args(0).matrix_value();
17363  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
17364  }
17365  {
17366  if ( _n_dims( args(1) ) > 1 )
17367  {
17368  error( "argument must be a scalar or vector" ); SWIG_fail;
17369  }
17370  if ( _dim( args(1), 0 ) != Alen )
17371  {
17372  error( "argument vectors must be same length" ); SWIG_fail;
17373  }
17374  temp3 = args(1).matrix_value();
17375  arg3 = new PLINT[Alen];
17376  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17377  }
17378  plpat(arg1,(int const *)arg2,(int const *)arg3);
17379  _outv = octave_value();
17380  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17381  {
17382  delete [] arg2;
17383  }
17384  {
17385  delete [] arg3;
17386  }
17387  return _out;
17388 fail:
17389  {
17390  delete [] arg2;
17391  }
17392  {
17393  delete [] arg3;
17394  }
17395  return octave_value_list();
17396 }
17397 
17398 
17399 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
17400  PLINT arg1 ;
17401  PLFLT *arg2 = (PLFLT *) 0 ;
17402  PLFLT *arg3 = (PLFLT *) 0 ;
17403  PLINT arg4 ;
17404  Matrix temp1 ;
17405  Matrix temp3 ;
17406  int val4 ;
17407  int ecode4 = 0 ;
17408  octave_value_list _out;
17409  octave_value_list *_outp=&_out;
17410  octave_value _outv;
17411 
17412  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
17413  SWIG_fail;
17414  }
17415  {
17416  if ( _n_dims( args(0) ) > 1 )
17417  {
17418  error( "argument must be a scalar or vector" ); SWIG_fail;
17419  }
17420  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17421  temp1 = args(0).matrix_value();
17422  arg2 = &temp1( 0, 0 );
17423  }
17424  {
17425  if ( _n_dims( args(1) ) > 1 )
17426  {
17427  error( "argument must be a scalar or vector" ); SWIG_fail;
17428  }
17429  if ( _dim( args(1), 0 ) != Alen )
17430  {
17431  error( "argument vectors must be same length" ); SWIG_fail;
17432  }
17433  temp3 = args(1).matrix_value();
17434  arg3 = &temp3( 0, 0 );
17435  }
17436  ecode4 = SWIG_AsVal_int(args(2), &val4);
17437  if (!SWIG_IsOK(ecode4)) {
17438  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
17439  }
17440  arg4 = (PLINT)(val4);
17441  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17442  _outv = octave_value();
17443  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17444  {
17445 
17446  }
17447  {
17448 
17449  }
17450  return _out;
17451 fail:
17452  {
17453 
17454  }
17455  {
17456 
17457  }
17458  return octave_value_list();
17459 }
17460 
17461 
17462 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
17463  PLINT arg1 ;
17464  PLFLT *arg2 = (PLFLT *) 0 ;
17465  PLFLT *arg3 = (PLFLT *) 0 ;
17466  PLFLT *arg4 = (PLFLT *) 0 ;
17467  PLINT arg5 ;
17468  Matrix temp1 ;
17469  Matrix temp3 ;
17470  Matrix temp4 ;
17471  int val5 ;
17472  int ecode5 = 0 ;
17473  octave_value_list _out;
17474  octave_value_list *_outp=&_out;
17475  octave_value _outv;
17476 
17477  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
17478  SWIG_fail;
17479  }
17480  {
17481  if ( _n_dims( args(0) ) > 1 )
17482  {
17483  error( "argument must be a scalar or vector" ); SWIG_fail;
17484  }
17485  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17486  temp1 = args(0).matrix_value();
17487  arg2 = &temp1( 0, 0 );
17488  }
17489  {
17490  if ( _n_dims( args(1) ) > 1 )
17491  {
17492  error( "argument must be a scalar or vector" ); SWIG_fail;
17493  }
17494  if ( _dim( args(1), 0 ) != Alen )
17495  {
17496  error( "argument vectors must be same length" ); SWIG_fail;
17497  }
17498  temp3 = args(1).matrix_value();
17499  arg3 = &temp3( 0, 0 );
17500  }
17501  {
17502  if ( _n_dims( args(2) ) > 1 )
17503  {
17504  error( "argument must be a scalar or vector" ); SWIG_fail;
17505  }
17506  if ( _dim( args(2), 0 ) != Alen )
17507  {
17508  error( "argument vectors must be same length" ); SWIG_fail;
17509  }
17510  temp4 = args(2).matrix_value();
17511  arg4 = &temp4( 0, 0 );
17512  }
17513  ecode5 = SWIG_AsVal_int(args(3), &val5);
17514  if (!SWIG_IsOK(ecode5)) {
17515  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
17516  }
17517  arg5 = (PLINT)(val5);
17518  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
17519  _outv = octave_value();
17520  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17521  {
17522 
17523  }
17524  {
17525 
17526  }
17527  {
17528 
17529  }
17530  return _out;
17531 fail:
17532  {
17533 
17534  }
17535  {
17536 
17537  }
17538  {
17539 
17540  }
17541  return octave_value_list();
17542 }
17543 
17544 
17545 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
17546  PLINT arg1 ;
17547  PLFLT *arg2 = (PLFLT *) 0 ;
17548  PLFLT *arg3 = (PLFLT *) 0 ;
17549  PLFLT *arg4 = (PLFLT *) 0 ;
17550  PLBOOL *arg5 = (PLBOOL *) 0 ;
17551  PLBOOL arg6 ;
17552  Matrix temp1 ;
17553  Matrix temp3 ;
17554  Matrix temp4 ;
17555  Matrix temp5 ;
17556  int val6 ;
17557  int ecode6 = 0 ;
17558  octave_value_list _out;
17559  octave_value_list *_outp=&_out;
17560  octave_value _outv;
17561 
17562  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
17563  SWIG_fail;
17564  }
17565  {
17566  if ( _n_dims( args(0) ) > 1 )
17567  {
17568  error( "argument must be a scalar or vector" ); SWIG_fail;
17569  }
17570  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17571  temp1 = args(0).matrix_value();
17572  arg2 = &temp1( 0, 0 );
17573  }
17574  {
17575  if ( _n_dims( args(1) ) > 1 )
17576  {
17577  error( "argument must be a scalar or vector" ); SWIG_fail;
17578  }
17579  if ( _dim( args(1), 0 ) != Alen )
17580  {
17581  error( "argument vectors must be same length" ); SWIG_fail;
17582  }
17583  temp3 = args(1).matrix_value();
17584  arg3 = &temp3( 0, 0 );
17585  }
17586  {
17587  if ( _n_dims( args(2) ) > 1 )
17588  {
17589  error( "argument must be a scalar or vector" ); SWIG_fail;
17590  }
17591  if ( _dim( args(2), 0 ) != Alen )
17592  {
17593  error( "argument vectors must be same length" ); SWIG_fail;
17594  }
17595  temp4 = args(2).matrix_value();
17596  arg4 = &temp4( 0, 0 );
17597  }
17598  {
17599  if ( _n_dims( args(3) ) > 1 )
17600  {
17601  error( "argument must be a scalar or vector" ); SWIG_fail;
17602  }
17603  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
17604  {
17605  error( "argument vector must be same length or one less" ); SWIG_fail;
17606  }
17607  temp5 = args(3).matrix_value();
17608  arg5 = new PLINT[Alen];
17609  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
17610  }
17611  ecode6 = SWIG_AsVal_int(args(4), &val6);
17612  if (!SWIG_IsOK(ecode6)) {
17613  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
17614  }
17615  arg6 = (PLBOOL)(val6);
17616  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
17617  _outv = octave_value();
17618  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17619  {
17620 
17621  }
17622  {
17623 
17624  }
17625  {
17626 
17627  }
17628  {
17629  delete [] arg5;
17630  }
17631  return _out;
17632 fail:
17633  {
17634 
17635  }
17636  {
17637 
17638  }
17639  {
17640 
17641  }
17642  {
17643  delete [] arg5;
17644  }
17645  return octave_value_list();
17646 }
17647 
17648 
17649 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
17650  PLINT arg1 ;
17651  PLINT arg2 ;
17652  int val1 ;
17653  int ecode1 = 0 ;
17654  int val2 ;
17655  int ecode2 = 0 ;
17656  octave_value_list _out;
17657  octave_value_list *_outp=&_out;
17658  octave_value _outv;
17659 
17660  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
17661  SWIG_fail;
17662  }
17663  ecode1 = SWIG_AsVal_int(args(0), &val1);
17664  if (!SWIG_IsOK(ecode1)) {
17665  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
17666  }
17667  arg1 = (PLINT)(val1);
17668  ecode2 = SWIG_AsVal_int(args(1), &val2);
17669  if (!SWIG_IsOK(ecode2)) {
17670  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
17671  }
17672  arg2 = (PLINT)(val2);
17673  plprec(arg1,arg2);
17674  _outv = octave_value();
17675  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17676  return _out;
17677 fail:
17678  return octave_value_list();
17679 }
17680 
17681 
17682 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
17683  PLINT arg1 ;
17684  int val1 ;
17685  int ecode1 = 0 ;
17686  octave_value_list _out;
17687  octave_value_list *_outp=&_out;
17688  octave_value _outv;
17689 
17690  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
17691  SWIG_fail;
17692  }
17693  ecode1 = SWIG_AsVal_int(args(0), &val1);
17694  if (!SWIG_IsOK(ecode1)) {
17695  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
17696  }
17697  arg1 = (PLINT)(val1);
17698  plpsty(arg1);
17699  _outv = octave_value();
17700  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17701  return _out;
17702 fail:
17703  return octave_value_list();
17704 }
17705 
17706 
17707 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
17708  PLFLT arg1 ;
17709  PLFLT arg2 ;
17710  PLFLT arg3 ;
17711  PLFLT arg4 ;
17712  PLFLT arg5 ;
17713  char *arg6 = (char *) 0 ;
17714  double val1 ;
17715  int ecode1 = 0 ;
17716  double val2 ;
17717  int ecode2 = 0 ;
17718  double val3 ;
17719  int ecode3 = 0 ;
17720  double val4 ;
17721  int ecode4 = 0 ;
17722  double val5 ;
17723  int ecode5 = 0 ;
17724  int res6 ;
17725  char *buf6 = 0 ;
17726  int alloc6 = 0 ;
17727  octave_value_list _out;
17728  octave_value_list *_outp=&_out;
17729  octave_value _outv;
17730 
17731  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
17732  SWIG_fail;
17733  }
17734  ecode1 = SWIG_AsVal_double(args(0), &val1);
17735  if (!SWIG_IsOK(ecode1)) {
17736  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
17737  }
17738  arg1 = (PLFLT)(val1);
17739  ecode2 = SWIG_AsVal_double(args(1), &val2);
17740  if (!SWIG_IsOK(ecode2)) {
17741  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
17742  }
17743  arg2 = (PLFLT)(val2);
17744  ecode3 = SWIG_AsVal_double(args(2), &val3);
17745  if (!SWIG_IsOK(ecode3)) {
17746  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
17747  }
17748  arg3 = (PLFLT)(val3);
17749  ecode4 = SWIG_AsVal_double(args(3), &val4);
17750  if (!SWIG_IsOK(ecode4)) {
17751  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
17752  }
17753  arg4 = (PLFLT)(val4);
17754  ecode5 = SWIG_AsVal_double(args(4), &val5);
17755  if (!SWIG_IsOK(ecode5)) {
17756  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
17757  }
17758  arg5 = (PLFLT)(val5);
17759  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17760  if (!SWIG_IsOK(res6)) {
17761  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
17762  }
17763  arg6 = (char *)(buf6);
17764  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
17765  _outv = octave_value();
17766  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17767  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17768  return _out;
17769 fail:
17770  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17771  return octave_value_list();
17772 }
17773 
17774 
17775 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
17776  PLFLT arg1 ;
17777  PLFLT arg2 ;
17778  PLFLT arg3 ;
17779  PLFLT arg4 ;
17780  PLFLT arg5 ;
17781  PLFLT arg6 ;
17782  PLFLT arg7 ;
17783  PLFLT arg8 ;
17784  PLFLT arg9 ;
17785  PLFLT arg10 ;
17786  char *arg11 = (char *) 0 ;
17787  double val1 ;
17788  int ecode1 = 0 ;
17789  double val2 ;
17790  int ecode2 = 0 ;
17791  double val3 ;
17792  int ecode3 = 0 ;
17793  double val4 ;
17794  int ecode4 = 0 ;
17795  double val5 ;
17796  int ecode5 = 0 ;
17797  double val6 ;
17798  int ecode6 = 0 ;
17799  double val7 ;
17800  int ecode7 = 0 ;
17801  double val8 ;
17802  int ecode8 = 0 ;
17803  double val9 ;
17804  int ecode9 = 0 ;
17805  double val10 ;
17806  int ecode10 = 0 ;
17807  int res11 ;
17808  char *buf11 = 0 ;
17809  int alloc11 = 0 ;
17810  octave_value_list _out;
17811  octave_value_list *_outp=&_out;
17812  octave_value _outv;
17813 
17814  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
17815  SWIG_fail;
17816  }
17817  ecode1 = SWIG_AsVal_double(args(0), &val1);
17818  if (!SWIG_IsOK(ecode1)) {
17819  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
17820  }
17821  arg1 = (PLFLT)(val1);
17822  ecode2 = SWIG_AsVal_double(args(1), &val2);
17823  if (!SWIG_IsOK(ecode2)) {
17824  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
17825  }
17826  arg2 = (PLFLT)(val2);
17827  ecode3 = SWIG_AsVal_double(args(2), &val3);
17828  if (!SWIG_IsOK(ecode3)) {
17829  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
17830  }
17831  arg3 = (PLFLT)(val3);
17832  ecode4 = SWIG_AsVal_double(args(3), &val4);
17833  if (!SWIG_IsOK(ecode4)) {
17834  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
17835  }
17836  arg4 = (PLFLT)(val4);
17837  ecode5 = SWIG_AsVal_double(args(4), &val5);
17838  if (!SWIG_IsOK(ecode5)) {
17839  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
17840  }
17841  arg5 = (PLFLT)(val5);
17842  ecode6 = SWIG_AsVal_double(args(5), &val6);
17843  if (!SWIG_IsOK(ecode6)) {
17844  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
17845  }
17846  arg6 = (PLFLT)(val6);
17847  ecode7 = SWIG_AsVal_double(args(6), &val7);
17848  if (!SWIG_IsOK(ecode7)) {
17849  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
17850  }
17851  arg7 = (PLFLT)(val7);
17852  ecode8 = SWIG_AsVal_double(args(7), &val8);
17853  if (!SWIG_IsOK(ecode8)) {
17854  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
17855  }
17856  arg8 = (PLFLT)(val8);
17857  ecode9 = SWIG_AsVal_double(args(8), &val9);
17858  if (!SWIG_IsOK(ecode9)) {
17859  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
17860  }
17861  arg9 = (PLFLT)(val9);
17862  ecode10 = SWIG_AsVal_double(args(9), &val10);
17863  if (!SWIG_IsOK(ecode10)) {
17864  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
17865  }
17866  arg10 = (PLFLT)(val10);
17867  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
17868  if (!SWIG_IsOK(res11)) {
17869  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
17870  }
17871  arg11 = (char *)(buf11);
17872  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
17873  _outv = octave_value();
17874  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17875  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
17876  return _out;
17877 fail:
17878  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
17879  return octave_value_list();
17880 }
17881 
17882 
17883 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
17884  octave_value_list _out;
17885  octave_value_list *_outp=&_out;
17886  octave_value _outv;
17887  PLFLT result;
17888 
17889  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
17890  SWIG_fail;
17891  }
17892  result = (PLFLT)plrandd();
17893  _outv = SWIG_From_double((double)(result));
17894  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17895  return _out;
17896 fail:
17897  return octave_value_list();
17898 }
17899 
17900 
17901 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
17902  octave_value_list _out;
17903  octave_value_list *_outp=&_out;
17904  octave_value _outv;
17905 
17906  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
17907  SWIG_fail;
17908  }
17909  plreplot();
17910  _outv = octave_value();
17911  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17912  return _out;
17913 fail:
17914  return octave_value_list();
17915 }
17916 
17917 
17918 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
17919  PLFLT arg1 ;
17920  PLFLT arg2 ;
17921  PLFLT arg3 ;
17922  PLFLT *arg4 = (PLFLT *) 0 ;
17923  PLFLT *arg5 = (PLFLT *) 0 ;
17924  PLFLT *arg6 = (PLFLT *) 0 ;
17925  double val1 ;
17926  int ecode1 = 0 ;
17927  double val2 ;
17928  int ecode2 = 0 ;
17929  double val3 ;
17930  int ecode3 = 0 ;
17931  PLFLT temp4 ;
17932  int res4 = SWIG_TMPOBJ ;
17933  PLFLT temp5 ;
17934  int res5 = SWIG_TMPOBJ ;
17935  PLFLT temp6 ;
17936  int res6 = SWIG_TMPOBJ ;
17937  octave_value_list _out;
17938  octave_value_list *_outp=&_out;
17939  octave_value _outv;
17940 
17941  arg4 = &temp4;
17942  arg5 = &temp5;
17943  arg6 = &temp6;
17944  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
17945  SWIG_fail;
17946  }
17947  ecode1 = SWIG_AsVal_double(args(0), &val1);
17948  if (!SWIG_IsOK(ecode1)) {
17949  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
17950  }
17951  arg1 = (PLFLT)(val1);
17952  ecode2 = SWIG_AsVal_double(args(1), &val2);
17953  if (!SWIG_IsOK(ecode2)) {
17954  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
17955  }
17956  arg2 = (PLFLT)(val2);
17957  ecode3 = SWIG_AsVal_double(args(2), &val3);
17958  if (!SWIG_IsOK(ecode3)) {
17959  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
17960  }
17961  arg3 = (PLFLT)(val3);
17962  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
17963  _outv = octave_value();
17964  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17965  if (SWIG_IsTmpObj(res4)) {
17966  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17967  } else {
17968  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17969  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17970  }
17971  if (SWIG_IsTmpObj(res5)) {
17972  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17973  } else {
17974  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17975  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17976  }
17977  if (SWIG_IsTmpObj(res6)) {
17978  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17979  } else {
17980  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17981  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17982  }
17983  return _out;
17984 fail:
17985  return octave_value_list();
17986 }
17987 
17988 
17989 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
17990  PLFLT arg1 ;
17991  PLFLT arg2 ;
17992  double val1 ;
17993  int ecode1 = 0 ;
17994  double val2 ;
17995  int ecode2 = 0 ;
17996  octave_value_list _out;
17997  octave_value_list *_outp=&_out;
17998  octave_value _outv;
17999 
18000  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
18001  SWIG_fail;
18002  }
18003  ecode1 = SWIG_AsVal_double(args(0), &val1);
18004  if (!SWIG_IsOK(ecode1)) {
18005  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
18006  }
18007  arg1 = (PLFLT)(val1);
18008  ecode2 = SWIG_AsVal_double(args(1), &val2);
18009  if (!SWIG_IsOK(ecode2)) {
18010  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
18011  }
18012  arg2 = (PLFLT)(val2);
18013  plschr(arg1,arg2);
18014  _outv = octave_value();
18015  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18016  return _out;
18017 fail:
18018  return octave_value_list();
18019 }
18020 
18021 
18022 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
18023  PLINT *arg1 = (PLINT *) 0 ;
18024  PLINT *arg2 = (PLINT *) 0 ;
18025  PLINT *arg3 = (PLINT *) 0 ;
18026  PLINT arg4 ;
18027  Matrix temp1 ;
18028  Matrix temp2 ;
18029  Matrix temp3 ;
18030  octave_value_list _out;
18031  octave_value_list *_outp=&_out;
18032  octave_value _outv;
18033 
18034  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
18035  SWIG_fail;
18036  }
18037  {
18038  if ( _n_dims( args(0) ) > 1 )
18039  {
18040  error( "argument must be a scalar or vector" ); SWIG_fail;
18041  }
18042  Alen = (PLINT) ( _dim( args(0), 0 ) );
18043  temp1 = args(0).matrix_value();
18044  arg1 = new PLINT[Alen];
18045  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
18046  }
18047  {
18048  if ( _n_dims( args(1) ) > 1 )
18049  {
18050  error( "argument must be a scalar or vector" ); SWIG_fail;
18051  }
18052  if ( _dim( args(1), 0 ) != Alen )
18053  {
18054  error( "argument vectors must be same length" ); SWIG_fail;
18055  }
18056  temp2 = args(1).matrix_value();
18057  arg2 = new PLINT[Alen];
18058  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
18059  }
18060  {
18061  if ( _n_dims( args(2) ) > 1 )
18062  {
18063  error( "argument must be a scalar or vector" ); SWIG_fail;
18064  }
18065  if ( _dim( args(2), 0 ) != Alen )
18066  {
18067  error( "argument vectors must be same length" ); SWIG_fail;
18068  }
18069  temp3 = args(2).matrix_value();
18070  arg3 = new PLINT[Alen];
18071  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
18072  arg4 = Alen;
18073  }
18074  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
18075  _outv = octave_value();
18076  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18077  {
18078  delete [] arg1;
18079  }
18080  {
18081  delete [] arg2;
18082  }
18083  {
18084  delete [] arg3;
18085  }
18086  return _out;
18087 fail:
18088  {
18089  delete [] arg1;
18090  }
18091  {
18092  delete [] arg2;
18093  }
18094  {
18095  delete [] arg3;
18096  }
18097  return octave_value_list();
18098 }
18099 
18100 
18101 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
18102  PLINT *arg1 = (PLINT *) 0 ;
18103  PLINT *arg2 = (PLINT *) 0 ;
18104  PLINT *arg3 = (PLINT *) 0 ;
18105  PLFLT *arg4 = (PLFLT *) 0 ;
18106  PLINT arg5 ;
18107  Matrix temp1 ;
18108  Matrix temp2 ;
18109  Matrix temp3 ;
18110  Matrix temp4 ;
18111  octave_value_list _out;
18112  octave_value_list *_outp=&_out;
18113  octave_value _outv;
18114 
18115  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
18116  SWIG_fail;
18117  }
18118  {
18119  if ( _n_dims( args(0) ) > 1 )
18120  {
18121  error( "argument must be a scalar or vector" ); SWIG_fail;
18122  }
18123  Alen = (PLINT) ( _dim( args(0), 0 ) );
18124  temp1 = args(0).matrix_value();
18125  arg1 = new PLINT[Alen];
18126  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
18127  }
18128  {
18129  if ( _n_dims( args(1) ) > 1 )
18130  {
18131  error( "argument must be a scalar or vector" ); SWIG_fail;
18132  }
18133  if ( _dim( args(1), 0 ) != Alen )
18134  {
18135  error( "argument vectors must be same length" ); SWIG_fail;
18136  }
18137  temp2 = args(1).matrix_value();
18138  arg2 = new PLINT[Alen];
18139  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
18140  }
18141  {
18142  if ( _n_dims( args(2) ) > 1 )
18143  {
18144  error( "argument must be a scalar or vector" ); SWIG_fail;
18145  }
18146  if ( _dim( args(2), 0 ) != Alen )
18147  {
18148  error( "argument vectors must be same length" ); SWIG_fail;
18149  }
18150  temp3 = args(2).matrix_value();
18151  arg3 = new PLINT[Alen];
18152  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
18153  }
18154  {
18155  if ( _n_dims( args(3) ) > 1 )
18156  {
18157  error( "argument must be a scalar or vector" ); SWIG_fail;
18158  }
18159  if ( _dim( args(3), 0 ) != Alen )
18160  {
18161  error( "argument vectors must be same length" ); SWIG_fail;
18162  }
18163  temp4 = args(3).matrix_value();
18164  arg4 = &temp4( 0, 0 );
18165  arg5 = (PLINT) ( _dim( args(3), 0 ) );
18166  }
18167  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
18168  _outv = octave_value();
18169  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18170  {
18171  delete [] arg1;
18172  }
18173  {
18174  delete [] arg2;
18175  }
18176  {
18177  delete [] arg3;
18178  }
18179  {
18180 
18181  }
18182  return _out;
18183 fail:
18184  {
18185  delete [] arg1;
18186  }
18187  {
18188  delete [] arg2;
18189  }
18190  {
18191  delete [] arg3;
18192  }
18193  {
18194 
18195  }
18196  return octave_value_list();
18197 }
18198 
18199 
18200 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
18201  PLINT arg1 ;
18202  int val1 ;
18203  int ecode1 = 0 ;
18204  octave_value_list _out;
18205  octave_value_list *_outp=&_out;
18206  octave_value _outv;
18207 
18208  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
18209  SWIG_fail;
18210  }
18211  ecode1 = SWIG_AsVal_int(args(0), &val1);
18212  if (!SWIG_IsOK(ecode1)) {
18213  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
18214  }
18215  arg1 = (PLINT)(val1);
18216  plscmap0n(arg1);
18217  _outv = octave_value();
18218  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18219  return _out;
18220 fail:
18221  return octave_value_list();
18222 }
18223 
18224 
18225 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
18226  PLINT *arg1 = (PLINT *) 0 ;
18227  PLINT *arg2 = (PLINT *) 0 ;
18228  PLINT *arg3 = (PLINT *) 0 ;
18229  PLINT arg4 ;
18230  Matrix temp1 ;
18231  Matrix temp2 ;
18232  Matrix temp3 ;
18233  octave_value_list _out;
18234  octave_value_list *_outp=&_out;
18235  octave_value _outv;
18236 
18237  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
18238  SWIG_fail;
18239  }
18240  {
18241  if ( _n_dims( args(0) ) > 1 )
18242  {
18243  error( "argument must be a scalar or vector" ); SWIG_fail;
18244  }
18245  Alen = (PLINT) ( _dim( args(0), 0 ) );
18246  temp1 = args(0).matrix_value();
18247  arg1 = new PLINT[Alen];
18248  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
18249  }
18250  {
18251  if ( _n_dims( args(1) ) > 1 )
18252  {
18253  error( "argument must be a scalar or vector" ); SWIG_fail;
18254  }
18255  if ( _dim( args(1), 0 ) != Alen )
18256  {
18257  error( "argument vectors must be same length" ); SWIG_fail;
18258  }
18259  temp2 = args(1).matrix_value();
18260  arg2 = new PLINT[Alen];
18261  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
18262  }
18263  {
18264  if ( _n_dims( args(2) ) > 1 )
18265  {
18266  error( "argument must be a scalar or vector" ); SWIG_fail;
18267  }
18268  if ( _dim( args(2), 0 ) != Alen )
18269  {
18270  error( "argument vectors must be same length" ); SWIG_fail;
18271  }
18272  temp3 = args(2).matrix_value();
18273  arg3 = new PLINT[Alen];
18274  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
18275  arg4 = Alen;
18276  }
18277  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
18278  _outv = octave_value();
18279  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18280  {
18281  delete [] arg1;
18282  }
18283  {
18284  delete [] arg2;
18285  }
18286  {
18287  delete [] arg3;
18288  }
18289  return _out;
18290 fail:
18291  {
18292  delete [] arg1;
18293  }
18294  {
18295  delete [] arg2;
18296  }
18297  {
18298  delete [] arg3;
18299  }
18300  return octave_value_list();
18301 }
18302 
18303 
18304 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
18305  PLINT *arg1 = (PLINT *) 0 ;
18306  PLINT *arg2 = (PLINT *) 0 ;
18307  PLINT *arg3 = (PLINT *) 0 ;
18308  PLFLT *arg4 = (PLFLT *) 0 ;
18309  PLINT arg5 ;
18310  Matrix temp1 ;
18311  Matrix temp2 ;
18312  Matrix temp3 ;
18313  Matrix temp4 ;
18314  octave_value_list _out;
18315  octave_value_list *_outp=&_out;
18316  octave_value _outv;
18317 
18318  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
18319  SWIG_fail;
18320  }
18321  {
18322  if ( _n_dims( args(0) ) > 1 )
18323  {
18324  error( "argument must be a scalar or vector" ); SWIG_fail;
18325  }
18326  Alen = (PLINT) ( _dim( args(0), 0 ) );
18327  temp1 = args(0).matrix_value();
18328  arg1 = new PLINT[Alen];
18329  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
18330  }
18331  {
18332  if ( _n_dims( args(1) ) > 1 )
18333  {
18334  error( "argument must be a scalar or vector" ); SWIG_fail;
18335  }
18336  if ( _dim( args(1), 0 ) != Alen )
18337  {
18338  error( "argument vectors must be same length" ); SWIG_fail;
18339  }
18340  temp2 = args(1).matrix_value();
18341  arg2 = new PLINT[Alen];
18342  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
18343  }
18344  {
18345  if ( _n_dims( args(2) ) > 1 )
18346  {
18347  error( "argument must be a scalar or vector" ); SWIG_fail;
18348  }
18349  if ( _dim( args(2), 0 ) != Alen )
18350  {
18351  error( "argument vectors must be same length" ); SWIG_fail;
18352  }
18353  temp3 = args(2).matrix_value();
18354  arg3 = new PLINT[Alen];
18355  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
18356  }
18357  {
18358  if ( _n_dims( args(3) ) > 1 )
18359  {
18360  error( "argument must be a scalar or vector" ); SWIG_fail;
18361  }
18362  if ( _dim( args(3), 0 ) != Alen )
18363  {
18364  error( "argument vectors must be same length" ); SWIG_fail;
18365  }
18366  temp4 = args(3).matrix_value();
18367  arg4 = &temp4( 0, 0 );
18368  arg5 = (PLINT) ( _dim( args(3), 0 ) );
18369  }
18370  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
18371  _outv = octave_value();
18372  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18373  {
18374  delete [] arg1;
18375  }
18376  {
18377  delete [] arg2;
18378  }
18379  {
18380  delete [] arg3;
18381  }
18382  {
18383 
18384  }
18385  return _out;
18386 fail:
18387  {
18388  delete [] arg1;
18389  }
18390  {
18391  delete [] arg2;
18392  }
18393  {
18394  delete [] arg3;
18395  }
18396  {
18397 
18398  }
18399  return octave_value_list();
18400 }
18401 
18402 
18403 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
18404  PLBOOL arg1 ;
18405  PLINT arg2 ;
18406  PLFLT *arg3 = (PLFLT *) 0 ;
18407  PLFLT *arg4 = (PLFLT *) 0 ;
18408  PLFLT *arg5 = (PLFLT *) 0 ;
18409  PLFLT *arg6 = (PLFLT *) 0 ;
18410  PLBOOL *arg7 = (PLBOOL *) 0 ;
18411  int val1 ;
18412  int ecode1 = 0 ;
18413  Matrix temp2 ;
18414  Matrix temp4 ;
18415  Matrix temp5 ;
18416  Matrix temp6 ;
18417  Matrix temp7 ;
18418  octave_value_list _out;
18419  octave_value_list *_outp=&_out;
18420  octave_value _outv;
18421 
18422  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
18423  SWIG_fail;
18424  }
18425  ecode1 = SWIG_AsVal_int(args(0), &val1);
18426  if (!SWIG_IsOK(ecode1)) {
18427  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
18428  }
18429  arg1 = (PLBOOL)(val1);
18430  {
18431  if ( _n_dims( args(1) ) > 1 )
18432  {
18433  error( "argument must be a scalar or vector" ); SWIG_fail;
18434  }
18435  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
18436  temp2 = args(1).matrix_value();
18437  arg3 = &temp2( 0, 0 );
18438  }
18439  {
18440  if ( _n_dims( args(2) ) > 1 )
18441  {
18442  error( "argument must be a scalar or vector" ); SWIG_fail;
18443  }
18444  if ( _dim( args(2), 0 ) != Alen )
18445  {
18446  error( "argument vectors must be same length" ); SWIG_fail;
18447  }
18448  temp4 = args(2).matrix_value();
18449  arg4 = &temp4( 0, 0 );
18450  }
18451  {
18452  if ( _n_dims( args(3) ) > 1 )
18453  {
18454  error( "argument must be a scalar or vector" ); SWIG_fail;
18455  }
18456  if ( _dim( args(3), 0 ) != Alen )
18457  {
18458  error( "argument vectors must be same length" ); SWIG_fail;
18459  }
18460  temp5 = args(3).matrix_value();
18461  arg5 = &temp5( 0, 0 );
18462  }
18463  {
18464  if ( _n_dims( args(4) ) > 1 )
18465  {
18466  error( "argument must be a scalar or vector" ); SWIG_fail;
18467  }
18468  if ( _dim( args(4), 0 ) != Alen )
18469  {
18470  error( "argument vectors must be same length" ); SWIG_fail;
18471  }
18472  temp6 = args(4).matrix_value();
18473  arg6 = &temp6( 0, 0 );
18474  }
18475  {
18476  if ( _n_dims( args(5) ) > 1 )
18477  {
18478  error( "argument must be a scalar or vector" ); SWIG_fail;
18479  }
18480  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
18481  {
18482  error( "argument vector must be same length or one less" ); SWIG_fail;
18483  }
18484  temp7 = args(5).matrix_value();
18485  arg7 = new PLINT[Alen];
18486  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
18487  }
18488  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
18489  _outv = octave_value();
18490  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18491  {
18492 
18493  }
18494  {
18495 
18496  }
18497  {
18498 
18499  }
18500  {
18501 
18502  }
18503  {
18504  delete [] arg7;
18505  }
18506  return _out;
18507 fail:
18508  {
18509 
18510  }
18511  {
18512 
18513  }
18514  {
18515 
18516  }
18517  {
18518 
18519  }
18520  {
18521  delete [] arg7;
18522  }
18523  return octave_value_list();
18524 }
18525 
18526 
18527 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
18528  PLBOOL arg1 ;
18529  PLINT arg2 ;
18530  PLFLT *arg3 = (PLFLT *) 0 ;
18531  PLFLT *arg4 = (PLFLT *) 0 ;
18532  PLFLT *arg5 = (PLFLT *) 0 ;
18533  PLFLT *arg6 = (PLFLT *) 0 ;
18534  PLFLT *arg7 = (PLFLT *) 0 ;
18535  PLBOOL *arg8 = (PLBOOL *) 0 ;
18536  int val1 ;
18537  int ecode1 = 0 ;
18538  Matrix temp2 ;
18539  Matrix temp4 ;
18540  Matrix temp5 ;
18541  Matrix temp6 ;
18542  Matrix temp7 ;
18543  Matrix temp8 ;
18544  octave_value_list _out;
18545  octave_value_list *_outp=&_out;
18546  octave_value _outv;
18547 
18548  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
18549  SWIG_fail;
18550  }
18551  ecode1 = SWIG_AsVal_int(args(0), &val1);
18552  if (!SWIG_IsOK(ecode1)) {
18553  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
18554  }
18555  arg1 = (PLBOOL)(val1);
18556  {
18557  if ( _n_dims( args(1) ) > 1 )
18558  {
18559  error( "argument must be a scalar or vector" ); SWIG_fail;
18560  }
18561  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
18562  temp2 = args(1).matrix_value();
18563  arg3 = &temp2( 0, 0 );
18564  }
18565  {
18566  if ( _n_dims( args(2) ) > 1 )
18567  {
18568  error( "argument must be a scalar or vector" ); SWIG_fail;
18569  }
18570  if ( _dim( args(2), 0 ) != Alen )
18571  {
18572  error( "argument vectors must be same length" ); SWIG_fail;
18573  }
18574  temp4 = args(2).matrix_value();
18575  arg4 = &temp4( 0, 0 );
18576  }
18577  {
18578  if ( _n_dims( args(3) ) > 1 )
18579  {
18580  error( "argument must be a scalar or vector" ); SWIG_fail;
18581  }
18582  if ( _dim( args(3), 0 ) != Alen )
18583  {
18584  error( "argument vectors must be same length" ); SWIG_fail;
18585  }
18586  temp5 = args(3).matrix_value();
18587  arg5 = &temp5( 0, 0 );
18588  }
18589  {
18590  if ( _n_dims( args(4) ) > 1 )
18591  {
18592  error( "argument must be a scalar or vector" ); SWIG_fail;
18593  }
18594  if ( _dim( args(4), 0 ) != Alen )
18595  {
18596  error( "argument vectors must be same length" ); SWIG_fail;
18597  }
18598  temp6 = args(4).matrix_value();
18599  arg6 = &temp6( 0, 0 );
18600  }
18601  {
18602  if ( _n_dims( args(5) ) > 1 )
18603  {
18604  error( "argument must be a scalar or vector" ); SWIG_fail;
18605  }
18606  if ( _dim( args(5), 0 ) != Alen )
18607  {
18608  error( "argument vectors must be same length" ); SWIG_fail;
18609  }
18610  temp7 = args(5).matrix_value();
18611  arg7 = &temp7( 0, 0 );
18612  }
18613  {
18614  if ( _n_dims( args(6) ) > 1 )
18615  {
18616  error( "argument must be a scalar or vector" ); SWIG_fail;
18617  }
18618  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
18619  {
18620  error( "argument vector must be same length or one less" ); SWIG_fail;
18621  }
18622  temp8 = args(6).matrix_value();
18623  arg8 = new PLINT[Alen];
18624  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
18625  }
18626  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
18627  _outv = octave_value();
18628  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18629  {
18630 
18631  }
18632  {
18633 
18634  }
18635  {
18636 
18637  }
18638  {
18639 
18640  }
18641  {
18642 
18643  }
18644  {
18645  delete [] arg8;
18646  }
18647  return _out;
18648 fail:
18649  {
18650 
18651  }
18652  {
18653 
18654  }
18655  {
18656 
18657  }
18658  {
18659 
18660  }
18661  {
18662 
18663  }
18664  {
18665  delete [] arg8;
18666  }
18667  return octave_value_list();
18668 }
18669 
18670 
18671 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
18672  PLINT arg1 ;
18673  int val1 ;
18674  int ecode1 = 0 ;
18675  octave_value_list _out;
18676  octave_value_list *_outp=&_out;
18677  octave_value _outv;
18678 
18679  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
18680  SWIG_fail;
18681  }
18682  ecode1 = SWIG_AsVal_int(args(0), &val1);
18683  if (!SWIG_IsOK(ecode1)) {
18684  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
18685  }
18686  arg1 = (PLINT)(val1);
18687  plscmap1n(arg1);
18688  _outv = octave_value();
18689  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18690  return _out;
18691 fail:
18692  return octave_value_list();
18693 }
18694 
18695 
18697  PLFLT arg1 ;
18698  PLFLT arg2 ;
18699  double val1 ;
18700  int ecode1 = 0 ;
18701  double val2 ;
18702  int ecode2 = 0 ;
18703  octave_value_list _out;
18704  octave_value_list *_outp=&_out;
18705  octave_value _outv;
18706 
18707  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
18708  SWIG_fail;
18709  }
18710  ecode1 = SWIG_AsVal_double(args(0), &val1);
18711  if (!SWIG_IsOK(ecode1)) {
18712  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
18713  }
18714  arg1 = (PLFLT)(val1);
18715  ecode2 = SWIG_AsVal_double(args(1), &val2);
18716  if (!SWIG_IsOK(ecode2)) {
18717  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
18718  }
18719  arg2 = (PLFLT)(val2);
18720  plscmap1_range(arg1,arg2);
18721  _outv = octave_value();
18722  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18723  return _out;
18724 fail:
18725  return octave_value_list();
18726 }
18727 
18728 
18730  PLFLT *arg1 = (PLFLT *) 0 ;
18731  PLFLT *arg2 = (PLFLT *) 0 ;
18732  PLFLT temp1 ;
18733  int res1 = SWIG_TMPOBJ ;
18734  PLFLT temp2 ;
18735  int res2 = SWIG_TMPOBJ ;
18736  octave_value_list _out;
18737  octave_value_list *_outp=&_out;
18738  octave_value _outv;
18739 
18740  arg1 = &temp1;
18741  arg2 = &temp2;
18742  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
18743  SWIG_fail;
18744  }
18745  plgcmap1_range(arg1,arg2);
18746  _outv = octave_value();
18747  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18748  if (SWIG_IsTmpObj(res1)) {
18749  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18750  } else {
18751  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18752  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18753  }
18754  if (SWIG_IsTmpObj(res2)) {
18755  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18756  } else {
18757  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18758  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18759  }
18760  return _out;
18761 fail:
18762  return octave_value_list();
18763 }
18764 
18765 
18766 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
18767  PLINT arg1 ;
18768  PLINT arg2 ;
18769  PLINT arg3 ;
18770  PLINT arg4 ;
18771  int val1 ;
18772  int ecode1 = 0 ;
18773  int val2 ;
18774  int ecode2 = 0 ;
18775  int val3 ;
18776  int ecode3 = 0 ;
18777  int val4 ;
18778  int ecode4 = 0 ;
18779  octave_value_list _out;
18780  octave_value_list *_outp=&_out;
18781  octave_value _outv;
18782 
18783  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
18784  SWIG_fail;
18785  }
18786  ecode1 = SWIG_AsVal_int(args(0), &val1);
18787  if (!SWIG_IsOK(ecode1)) {
18788  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
18789  }
18790  arg1 = (PLINT)(val1);
18791  ecode2 = SWIG_AsVal_int(args(1), &val2);
18792  if (!SWIG_IsOK(ecode2)) {
18793  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
18794  }
18795  arg2 = (PLINT)(val2);
18796  ecode3 = SWIG_AsVal_int(args(2), &val3);
18797  if (!SWIG_IsOK(ecode3)) {
18798  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
18799  }
18800  arg3 = (PLINT)(val3);
18801  ecode4 = SWIG_AsVal_int(args(3), &val4);
18802  if (!SWIG_IsOK(ecode4)) {
18803  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
18804  }
18805  arg4 = (PLINT)(val4);
18806  plscol0(arg1,arg2,arg3,arg4);
18807  _outv = octave_value();
18808  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18809  return _out;
18810 fail:
18811  return octave_value_list();
18812 }
18813 
18814 
18815 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
18816  PLINT arg1 ;
18817  PLINT arg2 ;
18818  PLINT arg3 ;
18819  PLINT arg4 ;
18820  PLFLT arg5 ;
18821  int val1 ;
18822  int ecode1 = 0 ;
18823  int val2 ;
18824  int ecode2 = 0 ;
18825  int val3 ;
18826  int ecode3 = 0 ;
18827  int val4 ;
18828  int ecode4 = 0 ;
18829  double val5 ;
18830  int ecode5 = 0 ;
18831  octave_value_list _out;
18832  octave_value_list *_outp=&_out;
18833  octave_value _outv;
18834 
18835  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
18836  SWIG_fail;
18837  }
18838  ecode1 = SWIG_AsVal_int(args(0), &val1);
18839  if (!SWIG_IsOK(ecode1)) {
18840  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
18841  }
18842  arg1 = (PLINT)(val1);
18843  ecode2 = SWIG_AsVal_int(args(1), &val2);
18844  if (!SWIG_IsOK(ecode2)) {
18845  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
18846  }
18847  arg2 = (PLINT)(val2);
18848  ecode3 = SWIG_AsVal_int(args(2), &val3);
18849  if (!SWIG_IsOK(ecode3)) {
18850  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
18851  }
18852  arg3 = (PLINT)(val3);
18853  ecode4 = SWIG_AsVal_int(args(3), &val4);
18854  if (!SWIG_IsOK(ecode4)) {
18855  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
18856  }
18857  arg4 = (PLINT)(val4);
18858  ecode5 = SWIG_AsVal_double(args(4), &val5);
18859  if (!SWIG_IsOK(ecode5)) {
18860  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
18861  }
18862  arg5 = (PLFLT)(val5);
18863  plscol0a(arg1,arg2,arg3,arg4,arg5);
18864  _outv = octave_value();
18865  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18866  return _out;
18867 fail:
18868  return octave_value_list();
18869 }
18870 
18871 
18872 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
18873  PLINT arg1 ;
18874  PLINT arg2 ;
18875  PLINT arg3 ;
18876  int val1 ;
18877  int ecode1 = 0 ;
18878  int val2 ;
18879  int ecode2 = 0 ;
18880  int val3 ;
18881  int ecode3 = 0 ;
18882  octave_value_list _out;
18883  octave_value_list *_outp=&_out;
18884  octave_value _outv;
18885 
18886  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
18887  SWIG_fail;
18888  }
18889  ecode1 = SWIG_AsVal_int(args(0), &val1);
18890  if (!SWIG_IsOK(ecode1)) {
18891  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
18892  }
18893  arg1 = (PLINT)(val1);
18894  ecode2 = SWIG_AsVal_int(args(1), &val2);
18895  if (!SWIG_IsOK(ecode2)) {
18896  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
18897  }
18898  arg2 = (PLINT)(val2);
18899  ecode3 = SWIG_AsVal_int(args(2), &val3);
18900  if (!SWIG_IsOK(ecode3)) {
18901  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
18902  }
18903  arg3 = (PLINT)(val3);
18904  plscolbg(arg1,arg2,arg3);
18905  _outv = octave_value();
18906  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18907  return _out;
18908 fail:
18909  return octave_value_list();
18910 }
18911 
18912 
18913 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
18914  PLINT arg1 ;
18915  PLINT arg2 ;
18916  PLINT arg3 ;
18917  PLFLT arg4 ;
18918  int val1 ;
18919  int ecode1 = 0 ;
18920  int val2 ;
18921  int ecode2 = 0 ;
18922  int val3 ;
18923  int ecode3 = 0 ;
18924  double val4 ;
18925  int ecode4 = 0 ;
18926  octave_value_list _out;
18927  octave_value_list *_outp=&_out;
18928  octave_value _outv;
18929 
18930  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
18931  SWIG_fail;
18932  }
18933  ecode1 = SWIG_AsVal_int(args(0), &val1);
18934  if (!SWIG_IsOK(ecode1)) {
18935  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
18936  }
18937  arg1 = (PLINT)(val1);
18938  ecode2 = SWIG_AsVal_int(args(1), &val2);
18939  if (!SWIG_IsOK(ecode2)) {
18940  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
18941  }
18942  arg2 = (PLINT)(val2);
18943  ecode3 = SWIG_AsVal_int(args(2), &val3);
18944  if (!SWIG_IsOK(ecode3)) {
18945  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
18946  }
18947  arg3 = (PLINT)(val3);
18948  ecode4 = SWIG_AsVal_double(args(3), &val4);
18949  if (!SWIG_IsOK(ecode4)) {
18950  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
18951  }
18952  arg4 = (PLFLT)(val4);
18953  plscolbga(arg1,arg2,arg3,arg4);
18954  _outv = octave_value();
18955  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18956  return _out;
18957 fail:
18958  return octave_value_list();
18959 }
18960 
18961 
18962 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
18963  PLINT arg1 ;
18964  int val1 ;
18965  int ecode1 = 0 ;
18966  octave_value_list _out;
18967  octave_value_list *_outp=&_out;
18968  octave_value _outv;
18969 
18970  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
18971  SWIG_fail;
18972  }
18973  ecode1 = SWIG_AsVal_int(args(0), &val1);
18974  if (!SWIG_IsOK(ecode1)) {
18975  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
18976  }
18977  arg1 = (PLINT)(val1);
18978  plscolor(arg1);
18979  _outv = octave_value();
18980  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18981  return _out;
18982 fail:
18983  return octave_value_list();
18984 }
18985 
18986 
18987 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
18988  PLINT arg1 ;
18989  int val1 ;
18990  int ecode1 = 0 ;
18991  octave_value_list _out;
18992  octave_value_list *_outp=&_out;
18993  octave_value _outv;
18994 
18995  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
18996  SWIG_fail;
18997  }
18998  ecode1 = SWIG_AsVal_int(args(0), &val1);
18999  if (!SWIG_IsOK(ecode1)) {
19000  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
19001  }
19002  arg1 = (PLINT)(val1);
19003  plscompression(arg1);
19004  _outv = octave_value();
19005  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19006  return _out;
19007 fail:
19008  return octave_value_list();
19009 }
19010 
19011 
19012 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
19013  char *arg1 = (char *) 0 ;
19014  int res1 ;
19015  char *buf1 = 0 ;
19016  int alloc1 = 0 ;
19017  octave_value_list _out;
19018  octave_value_list *_outp=&_out;
19019  octave_value _outv;
19020 
19021  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
19022  SWIG_fail;
19023  }
19024  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19025  if (!SWIG_IsOK(res1)) {
19026  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
19027  }
19028  arg1 = (char *)(buf1);
19029  plsdev((char const *)arg1);
19030  _outv = octave_value();
19031  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19032  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19033  return _out;
19034 fail:
19035  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19036  return octave_value_list();
19037 }
19038 
19039 
19040 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
19041  PLFLT arg1 ;
19042  PLFLT arg2 ;
19043  PLFLT arg3 ;
19044  PLFLT arg4 ;
19045  double val1 ;
19046  int ecode1 = 0 ;
19047  double val2 ;
19048  int ecode2 = 0 ;
19049  double val3 ;
19050  int ecode3 = 0 ;
19051  double val4 ;
19052  int ecode4 = 0 ;
19053  octave_value_list _out;
19054  octave_value_list *_outp=&_out;
19055  octave_value _outv;
19056 
19057  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
19058  SWIG_fail;
19059  }
19060  ecode1 = SWIG_AsVal_double(args(0), &val1);
19061  if (!SWIG_IsOK(ecode1)) {
19062  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
19063  }
19064  arg1 = (PLFLT)(val1);
19065  ecode2 = SWIG_AsVal_double(args(1), &val2);
19066  if (!SWIG_IsOK(ecode2)) {
19067  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
19068  }
19069  arg2 = (PLFLT)(val2);
19070  ecode3 = SWIG_AsVal_double(args(2), &val3);
19071  if (!SWIG_IsOK(ecode3)) {
19072  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
19073  }
19074  arg3 = (PLFLT)(val3);
19075  ecode4 = SWIG_AsVal_double(args(3), &val4);
19076  if (!SWIG_IsOK(ecode4)) {
19077  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
19078  }
19079  arg4 = (PLFLT)(val4);
19080  plsdidev(arg1,arg2,arg3,arg4);
19081  _outv = octave_value();
19082  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19083  return _out;
19084 fail:
19085  return octave_value_list();
19086 }
19087 
19088 
19089 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
19090  PLINT arg1 ;
19091  PLINT arg2 ;
19092  PLINT arg3 ;
19093  PLINT arg4 ;
19094  PLFLT arg5 ;
19095  PLFLT arg6 ;
19096  int val1 ;
19097  int ecode1 = 0 ;
19098  int val2 ;
19099  int ecode2 = 0 ;
19100  int val3 ;
19101  int ecode3 = 0 ;
19102  int val4 ;
19103  int ecode4 = 0 ;
19104  double val5 ;
19105  int ecode5 = 0 ;
19106  double val6 ;
19107  int ecode6 = 0 ;
19108  octave_value_list _out;
19109  octave_value_list *_outp=&_out;
19110  octave_value _outv;
19111 
19112  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
19113  SWIG_fail;
19114  }
19115  ecode1 = SWIG_AsVal_int(args(0), &val1);
19116  if (!SWIG_IsOK(ecode1)) {
19117  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
19118  }
19119  arg1 = (PLINT)(val1);
19120  ecode2 = SWIG_AsVal_int(args(1), &val2);
19121  if (!SWIG_IsOK(ecode2)) {
19122  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
19123  }
19124  arg2 = (PLINT)(val2);
19125  ecode3 = SWIG_AsVal_int(args(2), &val3);
19126  if (!SWIG_IsOK(ecode3)) {
19127  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
19128  }
19129  arg3 = (PLINT)(val3);
19130  ecode4 = SWIG_AsVal_int(args(3), &val4);
19131  if (!SWIG_IsOK(ecode4)) {
19132  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
19133  }
19134  arg4 = (PLINT)(val4);
19135  ecode5 = SWIG_AsVal_double(args(4), &val5);
19136  if (!SWIG_IsOK(ecode5)) {
19137  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
19138  }
19139  arg5 = (PLFLT)(val5);
19140  ecode6 = SWIG_AsVal_double(args(5), &val6);
19141  if (!SWIG_IsOK(ecode6)) {
19142  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
19143  }
19144  arg6 = (PLFLT)(val6);
19145  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
19146  _outv = octave_value();
19147  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19148  return _out;
19149 fail:
19150  return octave_value_list();
19151 }
19152 
19153 
19154 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
19155  PLFLT arg1 ;
19156  double val1 ;
19157  int ecode1 = 0 ;
19158  octave_value_list _out;
19159  octave_value_list *_outp=&_out;
19160  octave_value _outv;
19161 
19162  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
19163  SWIG_fail;
19164  }
19165  ecode1 = SWIG_AsVal_double(args(0), &val1);
19166  if (!SWIG_IsOK(ecode1)) {
19167  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
19168  }
19169  arg1 = (PLFLT)(val1);
19170  plsdiori(arg1);
19171  _outv = octave_value();
19172  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19173  return _out;
19174 fail:
19175  return octave_value_list();
19176 }
19177 
19178 
19179 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
19180  PLFLT arg1 ;
19181  PLFLT arg2 ;
19182  PLFLT arg3 ;
19183  PLFLT arg4 ;
19184  double val1 ;
19185  int ecode1 = 0 ;
19186  double val2 ;
19187  int ecode2 = 0 ;
19188  double val3 ;
19189  int ecode3 = 0 ;
19190  double val4 ;
19191  int ecode4 = 0 ;
19192  octave_value_list _out;
19193  octave_value_list *_outp=&_out;
19194  octave_value _outv;
19195 
19196  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
19197  SWIG_fail;
19198  }
19199  ecode1 = SWIG_AsVal_double(args(0), &val1);
19200  if (!SWIG_IsOK(ecode1)) {
19201  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
19202  }
19203  arg1 = (PLFLT)(val1);
19204  ecode2 = SWIG_AsVal_double(args(1), &val2);
19205  if (!SWIG_IsOK(ecode2)) {
19206  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
19207  }
19208  arg2 = (PLFLT)(val2);
19209  ecode3 = SWIG_AsVal_double(args(2), &val3);
19210  if (!SWIG_IsOK(ecode3)) {
19211  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
19212  }
19213  arg3 = (PLFLT)(val3);
19214  ecode4 = SWIG_AsVal_double(args(3), &val4);
19215  if (!SWIG_IsOK(ecode4)) {
19216  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
19217  }
19218  arg4 = (PLFLT)(val4);
19219  plsdiplt(arg1,arg2,arg3,arg4);
19220  _outv = octave_value();
19221  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19222  return _out;
19223 fail:
19224  return octave_value_list();
19225 }
19226 
19227 
19228 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
19229  PLFLT arg1 ;
19230  PLFLT arg2 ;
19231  PLFLT arg3 ;
19232  PLFLT arg4 ;
19233  double val1 ;
19234  int ecode1 = 0 ;
19235  double val2 ;
19236  int ecode2 = 0 ;
19237  double val3 ;
19238  int ecode3 = 0 ;
19239  double val4 ;
19240  int ecode4 = 0 ;
19241  octave_value_list _out;
19242  octave_value_list *_outp=&_out;
19243  octave_value _outv;
19244 
19245  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
19246  SWIG_fail;
19247  }
19248  ecode1 = SWIG_AsVal_double(args(0), &val1);
19249  if (!SWIG_IsOK(ecode1)) {
19250  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
19251  }
19252  arg1 = (PLFLT)(val1);
19253  ecode2 = SWIG_AsVal_double(args(1), &val2);
19254  if (!SWIG_IsOK(ecode2)) {
19255  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
19256  }
19257  arg2 = (PLFLT)(val2);
19258  ecode3 = SWIG_AsVal_double(args(2), &val3);
19259  if (!SWIG_IsOK(ecode3)) {
19260  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
19261  }
19262  arg3 = (PLFLT)(val3);
19263  ecode4 = SWIG_AsVal_double(args(3), &val4);
19264  if (!SWIG_IsOK(ecode4)) {
19265  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
19266  }
19267  arg4 = (PLFLT)(val4);
19268  plsdiplz(arg1,arg2,arg3,arg4);
19269  _outv = octave_value();
19270  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19271  return _out;
19272 fail:
19273  return octave_value_list();
19274 }
19275 
19276 
19277 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
19278  unsigned int arg1 ;
19279  unsigned int val1 ;
19280  int ecode1 = 0 ;
19281  octave_value_list _out;
19282  octave_value_list *_outp=&_out;
19283  octave_value _outv;
19284 
19285  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
19286  SWIG_fail;
19287  }
19288  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
19289  if (!SWIG_IsOK(ecode1)) {
19290  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
19291  }
19292  arg1 = (unsigned int)(val1);
19293  plseed(arg1);
19294  _outv = octave_value();
19295  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19296  return _out;
19297 fail:
19298  return octave_value_list();
19299 }
19300 
19301 
19302 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
19303  char arg1 ;
19304  char val1 ;
19305  int ecode1 = 0 ;
19306  octave_value_list _out;
19307  octave_value_list *_outp=&_out;
19308  octave_value _outv;
19309 
19310  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
19311  SWIG_fail;
19312  }
19313  ecode1 = SWIG_AsVal_char(args(0), &val1);
19314  if (!SWIG_IsOK(ecode1)) {
19315  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
19316  }
19317  arg1 = (char)(val1);
19318  plsesc(arg1);
19319  _outv = octave_value();
19320  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19321  return _out;
19322 fail:
19323  return octave_value_list();
19324 }
19325 
19326 
19327 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
19328  char *arg1 = (char *) 0 ;
19329  char *arg2 = (char *) 0 ;
19330  int res1 ;
19331  char *buf1 = 0 ;
19332  int alloc1 = 0 ;
19333  int res2 ;
19334  char *buf2 = 0 ;
19335  int alloc2 = 0 ;
19336  octave_value_list _out;
19337  octave_value_list *_outp=&_out;
19338  octave_value _outv;
19339  PLINT result;
19340 
19341  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
19342  SWIG_fail;
19343  }
19344  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19345  if (!SWIG_IsOK(res1)) {
19346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
19347  }
19348  arg1 = (char *)(buf1);
19349  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
19350  if (!SWIG_IsOK(res2)) {
19351  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
19352  }
19353  arg2 = (char *)(buf2);
19354  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
19355  _outv = SWIG_From_int((int)(result));
19356  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19357  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19358  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19359  return _out;
19360 fail:
19361  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19362  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19363  return octave_value_list();
19364 }
19365 
19366 
19367 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
19368  PLINT arg1 ;
19369  PLINT arg2 ;
19370  PLINT arg3 ;
19371  int val1 ;
19372  int ecode1 = 0 ;
19373  int val2 ;
19374  int ecode2 = 0 ;
19375  int val3 ;
19376  int ecode3 = 0 ;
19377  octave_value_list _out;
19378  octave_value_list *_outp=&_out;
19379  octave_value _outv;
19380 
19381  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
19382  SWIG_fail;
19383  }
19384  ecode1 = SWIG_AsVal_int(args(0), &val1);
19385  if (!SWIG_IsOK(ecode1)) {
19386  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
19387  }
19388  arg1 = (PLINT)(val1);
19389  ecode2 = SWIG_AsVal_int(args(1), &val2);
19390  if (!SWIG_IsOK(ecode2)) {
19391  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
19392  }
19393  arg2 = (PLINT)(val2);
19394  ecode3 = SWIG_AsVal_int(args(2), &val3);
19395  if (!SWIG_IsOK(ecode3)) {
19396  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
19397  }
19398  arg3 = (PLINT)(val3);
19399  plsfam(arg1,arg2,arg3);
19400  _outv = octave_value();
19401  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19402  return _out;
19403 fail:
19404  return octave_value_list();
19405 }
19406 
19407 
19408 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
19409  PLUNICODE arg1 ;
19410  unsigned int val1 ;
19411  int ecode1 = 0 ;
19412  octave_value_list _out;
19413  octave_value_list *_outp=&_out;
19414  octave_value _outv;
19415 
19416  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
19417  SWIG_fail;
19418  }
19419  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
19420  if (!SWIG_IsOK(ecode1)) {
19421  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
19422  }
19423  arg1 = (PLUNICODE)(val1);
19424  plsfci(arg1);
19425  _outv = octave_value();
19426  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19427  return _out;
19428 fail:
19429  return octave_value_list();
19430 }
19431 
19432 
19433 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
19434  char *arg1 = (char *) 0 ;
19435  int res1 ;
19436  char *buf1 = 0 ;
19437  int alloc1 = 0 ;
19438  octave_value_list _out;
19439  octave_value_list *_outp=&_out;
19440  octave_value _outv;
19441 
19442  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
19443  SWIG_fail;
19444  }
19445  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19446  if (!SWIG_IsOK(res1)) {
19447  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
19448  }
19449  arg1 = (char *)(buf1);
19450  plsfnam((char const *)arg1);
19451  _outv = octave_value();
19452  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19453  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19454  return _out;
19455 fail:
19456  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19457  return octave_value_list();
19458 }
19459 
19460 
19461 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
19462  PLINT arg1 ;
19463  PLINT arg2 ;
19464  PLINT arg3 ;
19465  int val1 ;
19466  int ecode1 = 0 ;
19467  int val2 ;
19468  int ecode2 = 0 ;
19469  int val3 ;
19470  int ecode3 = 0 ;
19471  octave_value_list _out;
19472  octave_value_list *_outp=&_out;
19473  octave_value _outv;
19474 
19475  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
19476  SWIG_fail;
19477  }
19478  ecode1 = SWIG_AsVal_int(args(0), &val1);
19479  if (!SWIG_IsOK(ecode1)) {
19480  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
19481  }
19482  arg1 = (PLINT)(val1);
19483  ecode2 = SWIG_AsVal_int(args(1), &val2);
19484  if (!SWIG_IsOK(ecode2)) {
19485  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
19486  }
19487  arg2 = (PLINT)(val2);
19488  ecode3 = SWIG_AsVal_int(args(2), &val3);
19489  if (!SWIG_IsOK(ecode3)) {
19490  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
19491  }
19492  arg3 = (PLINT)(val3);
19493  plsfont(arg1,arg2,arg3);
19494  _outv = octave_value();
19495  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19496  return _out;
19497 fail:
19498  return octave_value_list();
19499 }
19500 
19501 
19502 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
19503  label_func arg1 = (label_func) 0 ;
19504  PLPointer arg2 = (PLPointer) 0 ;
19505  int res2 ;
19506  octave_value_list _out;
19507  octave_value_list *_outp=&_out;
19508  octave_value _outv;
19509 
19510  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
19511  SWIG_fail;
19512  }
19513  {
19514  octave_value obj = args(0);
19515  if ( !obj.is_empty() )
19516  {
19517  if ( obj.is_function_handle() || obj.is_inline_function() )
19518  {
19519  fcnLabelFunc = obj.function_value();
19520  }
19521  else if ( obj.is_string() )
19522  {
19523  nameLabelFunc = obj.string_value();
19524  fcnLabelFunc = NULL;
19525  }
19526  arg1 = labelfunc_octave;
19527  }
19528  else
19529  {
19530  arg1 = NULL;
19531  }
19532  }
19533  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
19534  if (!SWIG_IsOK(res2)) {
19535  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
19536  }
19537  plslabelfunc(arg1,arg2);
19538  _outv = octave_value();
19539  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19540  return _out;
19541 fail:
19542  return octave_value_list();
19543 }
19544 
19545 
19546 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
19547  PLFLT arg1 ;
19548  PLFLT arg2 ;
19549  double val1 ;
19550  int ecode1 = 0 ;
19551  double val2 ;
19552  int ecode2 = 0 ;
19553  octave_value_list _out;
19554  octave_value_list *_outp=&_out;
19555  octave_value _outv;
19556 
19557  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
19558  SWIG_fail;
19559  }
19560  ecode1 = SWIG_AsVal_double(args(0), &val1);
19561  if (!SWIG_IsOK(ecode1)) {
19562  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
19563  }
19564  arg1 = (PLFLT)(val1);
19565  ecode2 = SWIG_AsVal_double(args(1), &val2);
19566  if (!SWIG_IsOK(ecode2)) {
19567  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
19568  }
19569  arg2 = (PLFLT)(val2);
19570  plsmaj(arg1,arg2);
19571  _outv = octave_value();
19572  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19573  return _out;
19574 fail:
19575  return octave_value_list();
19576 }
19577 
19578 
19579 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
19580  PLFLT arg1 ;
19581  PLFLT arg2 ;
19582  double val1 ;
19583  int ecode1 = 0 ;
19584  double val2 ;
19585  int ecode2 = 0 ;
19586  octave_value_list _out;
19587  octave_value_list *_outp=&_out;
19588  octave_value _outv;
19589 
19590  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
19591  SWIG_fail;
19592  }
19593  ecode1 = SWIG_AsVal_double(args(0), &val1);
19594  if (!SWIG_IsOK(ecode1)) {
19595  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
19596  }
19597  arg1 = (PLFLT)(val1);
19598  ecode2 = SWIG_AsVal_double(args(1), &val2);
19599  if (!SWIG_IsOK(ecode2)) {
19600  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
19601  }
19602  arg2 = (PLFLT)(val2);
19603  plsmin(arg1,arg2);
19604  _outv = octave_value();
19605  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19606  return _out;
19607 fail:
19608  return octave_value_list();
19609 }
19610 
19611 
19612 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
19613  PLINT arg1 ;
19614  int val1 ;
19615  int ecode1 = 0 ;
19616  octave_value_list _out;
19617  octave_value_list *_outp=&_out;
19618  octave_value _outv;
19619 
19620  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
19621  SWIG_fail;
19622  }
19623  ecode1 = SWIG_AsVal_int(args(0), &val1);
19624  if (!SWIG_IsOK(ecode1)) {
19625  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
19626  }
19627  arg1 = (PLINT)(val1);
19628  plsori(arg1);
19629  _outv = octave_value();
19630  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19631  return _out;
19632 fail:
19633  return octave_value_list();
19634 }
19635 
19636 
19637 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
19638  PLFLT arg1 ;
19639  PLFLT arg2 ;
19640  PLINT arg3 ;
19641  PLINT arg4 ;
19642  PLINT arg5 ;
19643  PLINT arg6 ;
19644  double val1 ;
19645  int ecode1 = 0 ;
19646  double val2 ;
19647  int ecode2 = 0 ;
19648  int val3 ;
19649  int ecode3 = 0 ;
19650  int val4 ;
19651  int ecode4 = 0 ;
19652  int val5 ;
19653  int ecode5 = 0 ;
19654  int val6 ;
19655  int ecode6 = 0 ;
19656  octave_value_list _out;
19657  octave_value_list *_outp=&_out;
19658  octave_value _outv;
19659 
19660  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
19661  SWIG_fail;
19662  }
19663  ecode1 = SWIG_AsVal_double(args(0), &val1);
19664  if (!SWIG_IsOK(ecode1)) {
19665  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
19666  }
19667  arg1 = (PLFLT)(val1);
19668  ecode2 = SWIG_AsVal_double(args(1), &val2);
19669  if (!SWIG_IsOK(ecode2)) {
19670  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
19671  }
19672  arg2 = (PLFLT)(val2);
19673  ecode3 = SWIG_AsVal_int(args(2), &val3);
19674  if (!SWIG_IsOK(ecode3)) {
19675  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
19676  }
19677  arg3 = (PLINT)(val3);
19678  ecode4 = SWIG_AsVal_int(args(3), &val4);
19679  if (!SWIG_IsOK(ecode4)) {
19680  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
19681  }
19682  arg4 = (PLINT)(val4);
19683  ecode5 = SWIG_AsVal_int(args(4), &val5);
19684  if (!SWIG_IsOK(ecode5)) {
19685  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
19686  }
19687  arg5 = (PLINT)(val5);
19688  ecode6 = SWIG_AsVal_int(args(5), &val6);
19689  if (!SWIG_IsOK(ecode6)) {
19690  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
19691  }
19692  arg6 = (PLINT)(val6);
19693  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
19694  _outv = octave_value();
19695  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19696  return _out;
19697 fail:
19698  return octave_value_list();
19699 }
19700 
19701 
19702 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
19703  char *arg1 = (char *) 0 ;
19704  int res1 ;
19705  char *buf1 = 0 ;
19706  int alloc1 = 0 ;
19707  octave_value_list _out;
19708  octave_value_list *_outp=&_out;
19709  octave_value _outv;
19710 
19711  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
19712  SWIG_fail;
19713  }
19714  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19715  if (!SWIG_IsOK(res1)) {
19716  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
19717  }
19718  arg1 = (char *)(buf1);
19719  plspal0((char const *)arg1);
19720  _outv = octave_value();
19721  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19722  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19723  return _out;
19724 fail:
19725  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19726  return octave_value_list();
19727 }
19728 
19729 
19730 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
19731  char *arg1 = (char *) 0 ;
19732  PLBOOL arg2 ;
19733  int res1 ;
19734  char *buf1 = 0 ;
19735  int alloc1 = 0 ;
19736  int val2 ;
19737  int ecode2 = 0 ;
19738  octave_value_list _out;
19739  octave_value_list *_outp=&_out;
19740  octave_value _outv;
19741 
19742  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
19743  SWIG_fail;
19744  }
19745  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19746  if (!SWIG_IsOK(res1)) {
19747  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
19748  }
19749  arg1 = (char *)(buf1);
19750  ecode2 = SWIG_AsVal_int(args(1), &val2);
19751  if (!SWIG_IsOK(ecode2)) {
19752  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
19753  }
19754  arg2 = (PLBOOL)(val2);
19755  plspal1((char const *)arg1,arg2);
19756  _outv = octave_value();
19757  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19758  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19759  return _out;
19760 fail:
19761  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19762  return octave_value_list();
19763 }
19764 
19765 
19766 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
19767  PLBOOL arg1 ;
19768  int val1 ;
19769  int ecode1 = 0 ;
19770  octave_value_list _out;
19771  octave_value_list *_outp=&_out;
19772  octave_value _outv;
19773 
19774  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
19775  SWIG_fail;
19776  }
19777  ecode1 = SWIG_AsVal_int(args(0), &val1);
19778  if (!SWIG_IsOK(ecode1)) {
19779  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
19780  }
19781  arg1 = (PLBOOL)(val1);
19782  plspause(arg1);
19783  _outv = octave_value();
19784  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19785  return _out;
19786 fail:
19787  return octave_value_list();
19788 }
19789 
19790 
19791 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
19792  PLINT arg1 ;
19793  int val1 ;
19794  int ecode1 = 0 ;
19795  octave_value_list _out;
19796  octave_value_list *_outp=&_out;
19797  octave_value _outv;
19798 
19799  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
19800  SWIG_fail;
19801  }
19802  ecode1 = SWIG_AsVal_int(args(0), &val1);
19803  if (!SWIG_IsOK(ecode1)) {
19804  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
19805  }
19806  arg1 = (PLINT)(val1);
19807  plsstrm(arg1);
19808  _outv = octave_value();
19809  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19810  return _out;
19811 fail:
19812  return octave_value_list();
19813 }
19814 
19815 
19816 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
19817  PLINT arg1 ;
19818  PLINT arg2 ;
19819  int val1 ;
19820  int ecode1 = 0 ;
19821  int val2 ;
19822  int ecode2 = 0 ;
19823  octave_value_list _out;
19824  octave_value_list *_outp=&_out;
19825  octave_value _outv;
19826 
19827  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
19828  SWIG_fail;
19829  }
19830  ecode1 = SWIG_AsVal_int(args(0), &val1);
19831  if (!SWIG_IsOK(ecode1)) {
19832  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
19833  }
19834  arg1 = (PLINT)(val1);
19835  ecode2 = SWIG_AsVal_int(args(1), &val2);
19836  if (!SWIG_IsOK(ecode2)) {
19837  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
19838  }
19839  arg2 = (PLINT)(val2);
19840  plssub(arg1,arg2);
19841  _outv = octave_value();
19842  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19843  return _out;
19844 fail:
19845  return octave_value_list();
19846 }
19847 
19848 
19849 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
19850  PLFLT arg1 ;
19851  PLFLT arg2 ;
19852  double val1 ;
19853  int ecode1 = 0 ;
19854  double val2 ;
19855  int ecode2 = 0 ;
19856  octave_value_list _out;
19857  octave_value_list *_outp=&_out;
19858  octave_value _outv;
19859 
19860  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
19861  SWIG_fail;
19862  }
19863  ecode1 = SWIG_AsVal_double(args(0), &val1);
19864  if (!SWIG_IsOK(ecode1)) {
19865  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
19866  }
19867  arg1 = (PLFLT)(val1);
19868  ecode2 = SWIG_AsVal_double(args(1), &val2);
19869  if (!SWIG_IsOK(ecode2)) {
19870  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
19871  }
19872  arg2 = (PLFLT)(val2);
19873  plssym(arg1,arg2);
19874  _outv = octave_value();
19875  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19876  return _out;
19877 fail:
19878  return octave_value_list();
19879 }
19880 
19881 
19882 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
19883  PLINT arg1 ;
19884  PLINT arg2 ;
19885  int val1 ;
19886  int ecode1 = 0 ;
19887  int val2 ;
19888  int ecode2 = 0 ;
19889  octave_value_list _out;
19890  octave_value_list *_outp=&_out;
19891  octave_value _outv;
19892 
19893  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
19894  SWIG_fail;
19895  }
19896  ecode1 = SWIG_AsVal_int(args(0), &val1);
19897  if (!SWIG_IsOK(ecode1)) {
19898  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
19899  }
19900  arg1 = (PLINT)(val1);
19901  ecode2 = SWIG_AsVal_int(args(1), &val2);
19902  if (!SWIG_IsOK(ecode2)) {
19903  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
19904  }
19905  arg2 = (PLINT)(val2);
19906  plstar(arg1,arg2);
19907  _outv = octave_value();
19908  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19909  return _out;
19910 fail:
19911  return octave_value_list();
19912 }
19913 
19914 
19915 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
19916  char *arg1 = (char *) 0 ;
19917  PLINT arg2 ;
19918  PLINT arg3 ;
19919  int res1 ;
19920  char *buf1 = 0 ;
19921  int alloc1 = 0 ;
19922  int val2 ;
19923  int ecode2 = 0 ;
19924  int val3 ;
19925  int ecode3 = 0 ;
19926  octave_value_list _out;
19927  octave_value_list *_outp=&_out;
19928  octave_value _outv;
19929 
19930  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
19931  SWIG_fail;
19932  }
19933  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19934  if (!SWIG_IsOK(res1)) {
19935  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
19936  }
19937  arg1 = (char *)(buf1);
19938  ecode2 = SWIG_AsVal_int(args(1), &val2);
19939  if (!SWIG_IsOK(ecode2)) {
19940  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
19941  }
19942  arg2 = (PLINT)(val2);
19943  ecode3 = SWIG_AsVal_int(args(2), &val3);
19944  if (!SWIG_IsOK(ecode3)) {
19945  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
19946  }
19947  arg3 = (PLINT)(val3);
19948  plstart((char const *)arg1,arg2,arg3);
19949  _outv = octave_value();
19950  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19951  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19952  return _out;
19953 fail:
19954  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19955  return octave_value_list();
19956 }
19957 
19958 
19959 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
19960  ct_func arg1 = (ct_func) 0 ;
19961  PLPointer arg2 = (PLPointer) 0 ;
19962  int res2 ;
19963  octave_value_list _out;
19964  octave_value_list *_outp=&_out;
19965  octave_value _outv;
19966 
19967  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
19968  SWIG_fail;
19969  }
19970  {
19971  octave_value obj = args(0);
19972  if ( !obj.is_empty() )
19973  {
19974  if ( obj.is_function_handle() || obj.is_inline_function() )
19975  {
19976  fcnCoordTrans = obj.function_value();
19977  }
19978  else if ( obj.is_string() )
19979  {
19980  nameCoordTrans = obj.string_value();
19981  fcnCoordTrans = NULL;
19982  }
19983  arg1 = ct_octave;
19984  }
19985  else
19986  {
19987  arg1 = NULL;
19988  }
19989  }
19990  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
19991  if (!SWIG_IsOK(res2)) {
19992  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
19993  }
19994  plstransform(arg1,arg2);
19995  _outv = octave_value();
19996  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19997  return _out;
19998 fail:
19999  return octave_value_list();
20000 }
20001 
20002 
20003 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
20004  PLINT arg1 ;
20005  PLFLT *arg2 = (PLFLT *) 0 ;
20006  PLFLT *arg3 = (PLFLT *) 0 ;
20007  char *arg4 = (char *) 0 ;
20008  Matrix temp1 ;
20009  Matrix temp3 ;
20010  int res4 ;
20011  char *buf4 = 0 ;
20012  int alloc4 = 0 ;
20013  octave_value_list _out;
20014  octave_value_list *_outp=&_out;
20015  octave_value _outv;
20016 
20017  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
20018  SWIG_fail;
20019  }
20020  {
20021  if ( _n_dims( args(0) ) > 1 )
20022  {
20023  error( "argument must be a scalar or vector" ); SWIG_fail;
20024  }
20025  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20026  temp1 = args(0).matrix_value();
20027  arg2 = &temp1( 0, 0 );
20028  }
20029  {
20030  if ( _n_dims( args(1) ) > 1 )
20031  {
20032  error( "argument must be a scalar or vector" ); SWIG_fail;
20033  }
20034  if ( _dim( args(1), 0 ) != Alen )
20035  {
20036  error( "argument vectors must be same length" ); SWIG_fail;
20037  }
20038  temp3 = args(1).matrix_value();
20039  arg3 = &temp3( 0, 0 );
20040  }
20041  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
20042  if (!SWIG_IsOK(res4)) {
20043  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
20044  }
20045  arg4 = (char *)(buf4);
20046  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
20047  _outv = octave_value();
20048  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20049  {
20050 
20051  }
20052  {
20053 
20054  }
20055  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
20056  return _out;
20057 fail:
20058  {
20059 
20060  }
20061  {
20062 
20063  }
20064  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
20065  return octave_value_list();
20066 }
20067 
20068 
20069 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
20070  PLINT arg1 ;
20071  PLFLT *arg2 = (PLFLT *) 0 ;
20072  PLFLT *arg3 = (PLFLT *) 0 ;
20073  PLFLT *arg4 = (PLFLT *) 0 ;
20074  char *arg5 = (char *) 0 ;
20075  Matrix temp1 ;
20076  Matrix temp3 ;
20077  Matrix temp4 ;
20078  int res5 ;
20079  char *buf5 = 0 ;
20080  int alloc5 = 0 ;
20081  octave_value_list _out;
20082  octave_value_list *_outp=&_out;
20083  octave_value _outv;
20084 
20085  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
20086  SWIG_fail;
20087  }
20088  {
20089  if ( _n_dims( args(0) ) > 1 )
20090  {
20091  error( "argument must be a scalar or vector" ); SWIG_fail;
20092  }
20093  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20094  temp1 = args(0).matrix_value();
20095  arg2 = &temp1( 0, 0 );
20096  }
20097  {
20098  if ( _n_dims( args(1) ) > 1 )
20099  {
20100  error( "argument must be a scalar or vector" ); SWIG_fail;
20101  }
20102  if ( _dim( args(1), 0 ) != Alen )
20103  {
20104  error( "argument vectors must be same length" ); SWIG_fail;
20105  }
20106  temp3 = args(1).matrix_value();
20107  arg3 = &temp3( 0, 0 );
20108  }
20109  {
20110  if ( _n_dims( args(2) ) > 1 )
20111  {
20112  error( "argument must be a scalar or vector" ); SWIG_fail;
20113  }
20114  if ( _dim( args(2), 0 ) != Alen )
20115  {
20116  error( "argument vectors must be same length" ); SWIG_fail;
20117  }
20118  temp4 = args(2).matrix_value();
20119  arg4 = &temp4( 0, 0 );
20120  }
20121  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
20122  if (!SWIG_IsOK(res5)) {
20123  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
20124  }
20125  arg5 = (char *)(buf5);
20126  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
20127  _outv = octave_value();
20128  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20129  {
20130 
20131  }
20132  {
20133 
20134  }
20135  {
20136 
20137  }
20138  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20139  return _out;
20140 fail:
20141  {
20142 
20143  }
20144  {
20145 
20146  }
20147  {
20148 
20149  }
20150  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20151  return octave_value_list();
20152 }
20153 
20154 
20155 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
20156  PLINT arg1 ;
20157  PLINT arg2 ;
20158  PLFLT arg3 ;
20159  PLFLT arg4 ;
20160  int val1 ;
20161  int ecode1 = 0 ;
20162  int val2 ;
20163  int ecode2 = 0 ;
20164  double val3 ;
20165  int ecode3 = 0 ;
20166  double val4 ;
20167  int ecode4 = 0 ;
20168  octave_value_list _out;
20169  octave_value_list *_outp=&_out;
20170  octave_value _outv;
20171 
20172  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
20173  SWIG_fail;
20174  }
20175  ecode1 = SWIG_AsVal_int(args(0), &val1);
20176  if (!SWIG_IsOK(ecode1)) {
20177  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
20178  }
20179  arg1 = (PLINT)(val1);
20180  ecode2 = SWIG_AsVal_int(args(1), &val2);
20181  if (!SWIG_IsOK(ecode2)) {
20182  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
20183  }
20184  arg2 = (PLINT)(val2);
20185  ecode3 = SWIG_AsVal_double(args(2), &val3);
20186  if (!SWIG_IsOK(ecode3)) {
20187  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
20188  }
20189  arg3 = (PLFLT)(val3);
20190  ecode4 = SWIG_AsVal_double(args(3), &val4);
20191  if (!SWIG_IsOK(ecode4)) {
20192  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
20193  }
20194  arg4 = (PLFLT)(val4);
20195  plstripa(arg1,arg2,arg3,arg4);
20196  _outv = octave_value();
20197  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20198  return _out;
20199 fail:
20200  return octave_value_list();
20201 }
20202 
20203 
20204 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
20205  PLINT arg1 ;
20206  int val1 ;
20207  int ecode1 = 0 ;
20208  octave_value_list _out;
20209  octave_value_list *_outp=&_out;
20210  octave_value _outv;
20211 
20212  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
20213  SWIG_fail;
20214  }
20215  ecode1 = SWIG_AsVal_int(args(0), &val1);
20216  if (!SWIG_IsOK(ecode1)) {
20217  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
20218  }
20219  arg1 = (PLINT)(val1);
20220  plstripd(arg1);
20221  _outv = octave_value();
20222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20223  return _out;
20224 fail:
20225  return octave_value_list();
20226 }
20227 
20228 
20229 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
20230  PLINT arg1 ;
20231  PLINT *arg2 = (PLINT *) 0 ;
20232  PLINT *arg3 = (PLINT *) 0 ;
20233  Matrix temp1 ;
20234  Matrix temp3 ;
20235  octave_value_list _out;
20236  octave_value_list *_outp=&_out;
20237  octave_value _outv;
20238 
20239  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
20240  SWIG_fail;
20241  }
20242  {
20243  if ( _n_dims( args(0) ) > 1 )
20244  {
20245  error( "argument must be a scalar or vector" ); SWIG_fail;
20246  }
20247  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20248  arg2 = new PLINT[Alen];
20249  temp1 = args(0).matrix_value();
20250  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
20251  }
20252  {
20253  if ( _n_dims( args(1) ) > 1 )
20254  {
20255  error( "argument must be a scalar or vector" ); SWIG_fail;
20256  }
20257  if ( _dim( args(1), 0 ) != Alen )
20258  {
20259  error( "argument vectors must be same length" ); SWIG_fail;
20260  }
20261  temp3 = args(1).matrix_value();
20262  arg3 = new PLINT[Alen];
20263  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20264  }
20265  plstyl(arg1,(int const *)arg2,(int const *)arg3);
20266  _outv = octave_value();
20267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20268  {
20269  delete [] arg2;
20270  }
20271  {
20272  delete [] arg3;
20273  }
20274  return _out;
20275 fail:
20276  {
20277  delete [] arg2;
20278  }
20279  {
20280  delete [] arg3;
20281  }
20282  return octave_value_list();
20283 }
20284 
20285 
20286 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
20287  PLFLT *arg1 = (PLFLT *) 0 ;
20288  PLFLT *arg2 = (PLFLT *) 0 ;
20289  PLINT arg3 ;
20290  PLBOOL arg4 ;
20291  Matrix temp1 ;
20292  Matrix temp2 ;
20293  int val4 ;
20294  int ecode4 = 0 ;
20295  octave_value_list _out;
20296  octave_value_list *_outp=&_out;
20297  octave_value _outv;
20298 
20299  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
20300  SWIG_fail;
20301  }
20302  {
20303  if ( _n_dims( args(0) ) > 1 )
20304  {
20305  error( "argument must be a scalar or vector" ); SWIG_fail;
20306  }
20307  Alen = (PLINT) ( _dim( args(0), 0 ) );
20308  temp1 = args(0).matrix_value();
20309  arg1 = &temp1( 0, 0 );
20310  }
20311  {
20312  if ( _n_dims( args(1) ) > 1 )
20313  {
20314  error( "argument must be a scalar or vector" ); SWIG_fail;
20315  }
20316  if ( _dim( args(1), 0 ) != Alen )
20317  {
20318  error( "argument vectors must be same length" ); SWIG_fail;
20319  }
20320  temp2 = args(1).matrix_value();
20321  arg2 = &temp2( 0, 0 );
20322  arg3 = (PLINT) ( _dim( args(1), 0 ) );
20323  }
20324  ecode4 = SWIG_AsVal_int(args(2), &val4);
20325  if (!SWIG_IsOK(ecode4)) {
20326  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
20327  }
20328  arg4 = (PLBOOL)(val4);
20329  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
20330  _outv = octave_value();
20331  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20332  {
20333 
20334  }
20335  {
20336 
20337  }
20338  return _out;
20339 fail:
20340  {
20341 
20342  }
20343  {
20344 
20345  }
20346  return octave_value_list();
20347 }
20348 
20349 
20350 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
20351  PLFLT arg1 ;
20352  PLFLT arg2 ;
20353  PLFLT arg3 ;
20354  PLFLT arg4 ;
20355  double val1 ;
20356  int ecode1 = 0 ;
20357  double val2 ;
20358  int ecode2 = 0 ;
20359  double val3 ;
20360  int ecode3 = 0 ;
20361  double val4 ;
20362  int ecode4 = 0 ;
20363  octave_value_list _out;
20364  octave_value_list *_outp=&_out;
20365  octave_value _outv;
20366 
20367  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
20368  SWIG_fail;
20369  }
20370  ecode1 = SWIG_AsVal_double(args(0), &val1);
20371  if (!SWIG_IsOK(ecode1)) {
20372  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
20373  }
20374  arg1 = (PLFLT)(val1);
20375  ecode2 = SWIG_AsVal_double(args(1), &val2);
20376  if (!SWIG_IsOK(ecode2)) {
20377  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
20378  }
20379  arg2 = (PLFLT)(val2);
20380  ecode3 = SWIG_AsVal_double(args(2), &val3);
20381  if (!SWIG_IsOK(ecode3)) {
20382  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
20383  }
20384  arg3 = (PLFLT)(val3);
20385  ecode4 = SWIG_AsVal_double(args(3), &val4);
20386  if (!SWIG_IsOK(ecode4)) {
20387  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
20388  }
20389  arg4 = (PLFLT)(val4);
20390  plsvpa(arg1,arg2,arg3,arg4);
20391  _outv = octave_value();
20392  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20393  return _out;
20394 fail:
20395  return octave_value_list();
20396 }
20397 
20398 
20399 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
20400  PLINT arg1 ;
20401  PLINT arg2 ;
20402  int val1 ;
20403  int ecode1 = 0 ;
20404  int val2 ;
20405  int ecode2 = 0 ;
20406  octave_value_list _out;
20407  octave_value_list *_outp=&_out;
20408  octave_value _outv;
20409 
20410  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
20411  SWIG_fail;
20412  }
20413  ecode1 = SWIG_AsVal_int(args(0), &val1);
20414  if (!SWIG_IsOK(ecode1)) {
20415  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
20416  }
20417  arg1 = (PLINT)(val1);
20418  ecode2 = SWIG_AsVal_int(args(1), &val2);
20419  if (!SWIG_IsOK(ecode2)) {
20420  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
20421  }
20422  arg2 = (PLINT)(val2);
20423  plsxax(arg1,arg2);
20424  _outv = octave_value();
20425  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20426  return _out;
20427 fail:
20428  return octave_value_list();
20429 }
20430 
20431 
20432 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
20433  PLINT arg1 ;
20434  PLINT arg2 ;
20435  int val1 ;
20436  int ecode1 = 0 ;
20437  int val2 ;
20438  int ecode2 = 0 ;
20439  octave_value_list _out;
20440  octave_value_list *_outp=&_out;
20441  octave_value _outv;
20442 
20443  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
20444  SWIG_fail;
20445  }
20446  ecode1 = SWIG_AsVal_int(args(0), &val1);
20447  if (!SWIG_IsOK(ecode1)) {
20448  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
20449  }
20450  arg1 = (PLINT)(val1);
20451  ecode2 = SWIG_AsVal_int(args(1), &val2);
20452  if (!SWIG_IsOK(ecode2)) {
20453  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
20454  }
20455  arg2 = (PLINT)(val2);
20456  plsyax(arg1,arg2);
20457  _outv = octave_value();
20458  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20459  return _out;
20460 fail:
20461  return octave_value_list();
20462 }
20463 
20464 
20465 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
20466  PLINT arg1 ;
20467  PLFLT *arg2 = (PLFLT *) 0 ;
20468  PLFLT *arg3 = (PLFLT *) 0 ;
20469  PLINT arg4 ;
20470  Matrix temp1 ;
20471  Matrix temp3 ;
20472  int val4 ;
20473  int ecode4 = 0 ;
20474  octave_value_list _out;
20475  octave_value_list *_outp=&_out;
20476  octave_value _outv;
20477 
20478  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
20479  SWIG_fail;
20480  }
20481  {
20482  if ( _n_dims( args(0) ) > 1 )
20483  {
20484  error( "argument must be a scalar or vector" ); SWIG_fail;
20485  }
20486  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20487  temp1 = args(0).matrix_value();
20488  arg2 = &temp1( 0, 0 );
20489  }
20490  {
20491  if ( _n_dims( args(1) ) > 1 )
20492  {
20493  error( "argument must be a scalar or vector" ); SWIG_fail;
20494  }
20495  if ( _dim( args(1), 0 ) != Alen )
20496  {
20497  error( "argument vectors must be same length" ); SWIG_fail;
20498  }
20499  temp3 = args(1).matrix_value();
20500  arg3 = &temp3( 0, 0 );
20501  }
20502  ecode4 = SWIG_AsVal_int(args(2), &val4);
20503  if (!SWIG_IsOK(ecode4)) {
20504  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
20505  }
20506  arg4 = (PLINT)(val4);
20507  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
20508  _outv = octave_value();
20509  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20510  {
20511 
20512  }
20513  {
20514 
20515  }
20516  return _out;
20517 fail:
20518  {
20519 
20520  }
20521  {
20522 
20523  }
20524  return octave_value_list();
20525 }
20526 
20527 
20528 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
20529  PLINT arg1 ;
20530  PLINT arg2 ;
20531  int val1 ;
20532  int ecode1 = 0 ;
20533  int val2 ;
20534  int ecode2 = 0 ;
20535  octave_value_list _out;
20536  octave_value_list *_outp=&_out;
20537  octave_value _outv;
20538 
20539  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
20540  SWIG_fail;
20541  }
20542  ecode1 = SWIG_AsVal_int(args(0), &val1);
20543  if (!SWIG_IsOK(ecode1)) {
20544  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
20545  }
20546  arg1 = (PLINT)(val1);
20547  ecode2 = SWIG_AsVal_int(args(1), &val2);
20548  if (!SWIG_IsOK(ecode2)) {
20549  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
20550  }
20551  arg2 = (PLINT)(val2);
20552  plszax(arg1,arg2);
20553  _outv = octave_value();
20554  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20555  return _out;
20556 fail:
20557  return octave_value_list();
20558 }
20559 
20560 
20561 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
20562  octave_value_list _out;
20563  octave_value_list *_outp=&_out;
20564  octave_value _outv;
20565 
20566  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
20567  SWIG_fail;
20568  }
20569  pltext();
20570  _outv = octave_value();
20571  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20572  return _out;
20573 fail:
20574  return octave_value_list();
20575 }
20576 
20577 
20578 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
20579  char *arg1 = (char *) 0 ;
20580  int res1 ;
20581  char *buf1 = 0 ;
20582  int alloc1 = 0 ;
20583  octave_value_list _out;
20584  octave_value_list *_outp=&_out;
20585  octave_value _outv;
20586 
20587  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
20588  SWIG_fail;
20589  }
20590  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20591  if (!SWIG_IsOK(res1)) {
20592  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
20593  }
20594  arg1 = (char *)(buf1);
20595  pltimefmt((char const *)arg1);
20596  _outv = octave_value();
20597  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20598  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20599  return _out;
20600 fail:
20601  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20602  return octave_value_list();
20603 }
20604 
20605 
20606 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
20607  PLFLT arg1 ;
20608  double val1 ;
20609  int ecode1 = 0 ;
20610  octave_value_list _out;
20611  octave_value_list *_outp=&_out;
20612  octave_value _outv;
20613 
20614  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
20615  SWIG_fail;
20616  }
20617  ecode1 = SWIG_AsVal_double(args(0), &val1);
20618  if (!SWIG_IsOK(ecode1)) {
20619  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
20620  }
20621  arg1 = (PLFLT)(val1);
20622  plvasp(arg1);
20623  _outv = octave_value();
20624  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20625  return _out;
20626 fail:
20627  return octave_value_list();
20628 }
20629 
20630 
20631 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
20632  PLFLT arg1 ;
20633  PLFLT arg2 ;
20634  PLFLT arg3 ;
20635  PLFLT arg4 ;
20636  PLFLT arg5 ;
20637  double val1 ;
20638  int ecode1 = 0 ;
20639  double val2 ;
20640  int ecode2 = 0 ;
20641  double val3 ;
20642  int ecode3 = 0 ;
20643  double val4 ;
20644  int ecode4 = 0 ;
20645  double val5 ;
20646  int ecode5 = 0 ;
20647  octave_value_list _out;
20648  octave_value_list *_outp=&_out;
20649  octave_value _outv;
20650 
20651  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
20652  SWIG_fail;
20653  }
20654  ecode1 = SWIG_AsVal_double(args(0), &val1);
20655  if (!SWIG_IsOK(ecode1)) {
20656  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
20657  }
20658  arg1 = (PLFLT)(val1);
20659  ecode2 = SWIG_AsVal_double(args(1), &val2);
20660  if (!SWIG_IsOK(ecode2)) {
20661  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
20662  }
20663  arg2 = (PLFLT)(val2);
20664  ecode3 = SWIG_AsVal_double(args(2), &val3);
20665  if (!SWIG_IsOK(ecode3)) {
20666  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
20667  }
20668  arg3 = (PLFLT)(val3);
20669  ecode4 = SWIG_AsVal_double(args(3), &val4);
20670  if (!SWIG_IsOK(ecode4)) {
20671  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
20672  }
20673  arg4 = (PLFLT)(val4);
20674  ecode5 = SWIG_AsVal_double(args(4), &val5);
20675  if (!SWIG_IsOK(ecode5)) {
20676  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
20677  }
20678  arg5 = (PLFLT)(val5);
20679  plvpas(arg1,arg2,arg3,arg4,arg5);
20680  _outv = octave_value();
20681  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20682  return _out;
20683 fail:
20684  return octave_value_list();
20685 }
20686 
20687 
20688 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
20689  PLFLT arg1 ;
20690  PLFLT arg2 ;
20691  PLFLT arg3 ;
20692  PLFLT arg4 ;
20693  double val1 ;
20694  int ecode1 = 0 ;
20695  double val2 ;
20696  int ecode2 = 0 ;
20697  double val3 ;
20698  int ecode3 = 0 ;
20699  double val4 ;
20700  int ecode4 = 0 ;
20701  octave_value_list _out;
20702  octave_value_list *_outp=&_out;
20703  octave_value _outv;
20704 
20705  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
20706  SWIG_fail;
20707  }
20708  ecode1 = SWIG_AsVal_double(args(0), &val1);
20709  if (!SWIG_IsOK(ecode1)) {
20710  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
20711  }
20712  arg1 = (PLFLT)(val1);
20713  ecode2 = SWIG_AsVal_double(args(1), &val2);
20714  if (!SWIG_IsOK(ecode2)) {
20715  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
20716  }
20717  arg2 = (PLFLT)(val2);
20718  ecode3 = SWIG_AsVal_double(args(2), &val3);
20719  if (!SWIG_IsOK(ecode3)) {
20720  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
20721  }
20722  arg3 = (PLFLT)(val3);
20723  ecode4 = SWIG_AsVal_double(args(3), &val4);
20724  if (!SWIG_IsOK(ecode4)) {
20725  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
20726  }
20727  arg4 = (PLFLT)(val4);
20728  plvpor(arg1,arg2,arg3,arg4);
20729  _outv = octave_value();
20730  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20731  return _out;
20732 fail:
20733  return octave_value_list();
20734 }
20735 
20736 
20737 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
20738  octave_value_list _out;
20739  octave_value_list *_outp=&_out;
20740  octave_value _outv;
20741 
20742  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
20743  SWIG_fail;
20744  }
20745  plvsta();
20746  _outv = octave_value();
20747  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20748  return _out;
20749 fail:
20750  return octave_value_list();
20751 }
20752 
20753 
20754 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
20755  PLFLT arg1 ;
20756  PLFLT arg2 ;
20757  PLFLT arg3 ;
20758  PLFLT arg4 ;
20759  PLFLT arg5 ;
20760  PLFLT arg6 ;
20761  PLFLT arg7 ;
20762  PLFLT arg8 ;
20763  PLFLT arg9 ;
20764  PLFLT arg10 ;
20765  PLFLT arg11 ;
20766  double val1 ;
20767  int ecode1 = 0 ;
20768  double val2 ;
20769  int ecode2 = 0 ;
20770  double val3 ;
20771  int ecode3 = 0 ;
20772  double val4 ;
20773  int ecode4 = 0 ;
20774  double val5 ;
20775  int ecode5 = 0 ;
20776  double val6 ;
20777  int ecode6 = 0 ;
20778  double val7 ;
20779  int ecode7 = 0 ;
20780  double val8 ;
20781  int ecode8 = 0 ;
20782  double val9 ;
20783  int ecode9 = 0 ;
20784  double val10 ;
20785  int ecode10 = 0 ;
20786  double val11 ;
20787  int ecode11 = 0 ;
20788  octave_value_list _out;
20789  octave_value_list *_outp=&_out;
20790  octave_value _outv;
20791 
20792  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
20793  SWIG_fail;
20794  }
20795  ecode1 = SWIG_AsVal_double(args(0), &val1);
20796  if (!SWIG_IsOK(ecode1)) {
20797  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
20798  }
20799  arg1 = (PLFLT)(val1);
20800  ecode2 = SWIG_AsVal_double(args(1), &val2);
20801  if (!SWIG_IsOK(ecode2)) {
20802  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
20803  }
20804  arg2 = (PLFLT)(val2);
20805  ecode3 = SWIG_AsVal_double(args(2), &val3);
20806  if (!SWIG_IsOK(ecode3)) {
20807  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
20808  }
20809  arg3 = (PLFLT)(val3);
20810  ecode4 = SWIG_AsVal_double(args(3), &val4);
20811  if (!SWIG_IsOK(ecode4)) {
20812  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
20813  }
20814  arg4 = (PLFLT)(val4);
20815  ecode5 = SWIG_AsVal_double(args(4), &val5);
20816  if (!SWIG_IsOK(ecode5)) {
20817  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
20818  }
20819  arg5 = (PLFLT)(val5);
20820  ecode6 = SWIG_AsVal_double(args(5), &val6);
20821  if (!SWIG_IsOK(ecode6)) {
20822  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
20823  }
20824  arg6 = (PLFLT)(val6);
20825  ecode7 = SWIG_AsVal_double(args(6), &val7);
20826  if (!SWIG_IsOK(ecode7)) {
20827  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
20828  }
20829  arg7 = (PLFLT)(val7);
20830  ecode8 = SWIG_AsVal_double(args(7), &val8);
20831  if (!SWIG_IsOK(ecode8)) {
20832  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
20833  }
20834  arg8 = (PLFLT)(val8);
20835  ecode9 = SWIG_AsVal_double(args(8), &val9);
20836  if (!SWIG_IsOK(ecode9)) {
20837  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
20838  }
20839  arg9 = (PLFLT)(val9);
20840  ecode10 = SWIG_AsVal_double(args(9), &val10);
20841  if (!SWIG_IsOK(ecode10)) {
20842  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
20843  }
20844  arg10 = (PLFLT)(val10);
20845  ecode11 = SWIG_AsVal_double(args(10), &val11);
20846  if (!SWIG_IsOK(ecode11)) {
20847  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
20848  }
20849  arg11 = (PLFLT)(val11);
20850  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
20851  _outv = octave_value();
20852  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20853  return _out;
20854 fail:
20855  return octave_value_list();
20856 }
20857 
20858 
20859 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
20860  PLINT arg1 ;
20861  int val1 ;
20862  int ecode1 = 0 ;
20863  octave_value_list _out;
20864  octave_value_list *_outp=&_out;
20865  octave_value _outv;
20866 
20867  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
20868  SWIG_fail;
20869  }
20870  ecode1 = SWIG_AsVal_int(args(0), &val1);
20871  if (!SWIG_IsOK(ecode1)) {
20872  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
20873  }
20874  arg1 = (PLINT)(val1);
20875  plwidth(arg1);
20876  _outv = octave_value();
20877  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20878  return _out;
20879 fail:
20880  return octave_value_list();
20881 }
20882 
20883 
20884 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
20885  PLFLT arg1 ;
20886  PLFLT arg2 ;
20887  PLFLT arg3 ;
20888  PLFLT arg4 ;
20889  double val1 ;
20890  int ecode1 = 0 ;
20891  double val2 ;
20892  int ecode2 = 0 ;
20893  double val3 ;
20894  int ecode3 = 0 ;
20895  double val4 ;
20896  int ecode4 = 0 ;
20897  octave_value_list _out;
20898  octave_value_list *_outp=&_out;
20899  octave_value _outv;
20900 
20901  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
20902  SWIG_fail;
20903  }
20904  ecode1 = SWIG_AsVal_double(args(0), &val1);
20905  if (!SWIG_IsOK(ecode1)) {
20906  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
20907  }
20908  arg1 = (PLFLT)(val1);
20909  ecode2 = SWIG_AsVal_double(args(1), &val2);
20910  if (!SWIG_IsOK(ecode2)) {
20911  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
20912  }
20913  arg2 = (PLFLT)(val2);
20914  ecode3 = SWIG_AsVal_double(args(2), &val3);
20915  if (!SWIG_IsOK(ecode3)) {
20916  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
20917  }
20918  arg3 = (PLFLT)(val3);
20919  ecode4 = SWIG_AsVal_double(args(3), &val4);
20920  if (!SWIG_IsOK(ecode4)) {
20921  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
20922  }
20923  arg4 = (PLFLT)(val4);
20924  plwind(arg1,arg2,arg3,arg4);
20925  _outv = octave_value();
20926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20927  return _out;
20928 fail:
20929  return octave_value_list();
20930 }
20931 
20932 
20933 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
20934  PLBOOL arg1 ;
20935  PLBOOL *arg2 = (PLBOOL *) 0 ;
20936  int val1 ;
20937  int ecode1 = 0 ;
20938  PLBOOL temp2 ;
20939  int res2 = SWIG_TMPOBJ ;
20940  octave_value_list _out;
20941  octave_value_list *_outp=&_out;
20942  octave_value _outv;
20943 
20944  arg2 = &temp2;
20945  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
20946  SWIG_fail;
20947  }
20948  ecode1 = SWIG_AsVal_int(args(0), &val1);
20949  if (!SWIG_IsOK(ecode1)) {
20950  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
20951  }
20952  arg1 = (PLBOOL)(val1);
20953  plxormod(arg1,arg2);
20954  _outv = octave_value();
20955  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20956  if (SWIG_IsTmpObj(res2)) {
20957  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20958  } else {
20959  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20960  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20961  }
20962  return _out;
20963 fail:
20964  return octave_value_list();
20965 }
20966 
20967 
20968 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
20969  mapform_func arg1 = (mapform_func) 0 ;
20970  char *arg2 = (char *) 0 ;
20971  PLFLT arg3 ;
20972  PLFLT arg4 ;
20973  PLFLT arg5 ;
20974  PLFLT arg6 ;
20975  int res2 ;
20976  char *buf2 = 0 ;
20977  int alloc2 = 0 ;
20978  double val3 ;
20979  int ecode3 = 0 ;
20980  double val4 ;
20981  int ecode4 = 0 ;
20982  double val5 ;
20983  int ecode5 = 0 ;
20984  double val6 ;
20985  int ecode6 = 0 ;
20986  octave_value_list _out;
20987  octave_value_list *_outp=&_out;
20988  octave_value _outv;
20989 
20990  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
20991  SWIG_fail;
20992  }
20993  {
20994  octave_value obj = args(0);
20995  if ( !obj.is_empty() )
20996  {
20997  if ( obj.is_function_handle() || obj.is_inline_function() )
20998  {
20999  fcnMapForm = obj.function_value();
21000  }
21001  else if ( obj.is_string() )
21002  {
21003  nameMapForm = obj.string_value();
21004  fcnMapForm = NULL;
21005  }
21006  arg1 = mapform_octave;
21007  }
21008  else
21009  {
21010  arg1 = NULL;
21011  }
21012  }
21013  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
21014  if (!SWIG_IsOK(res2)) {
21015  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
21016  }
21017  arg2 = (char *)(buf2);
21018  ecode3 = SWIG_AsVal_double(args(2), &val3);
21019  if (!SWIG_IsOK(ecode3)) {
21020  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
21021  }
21022  arg3 = (PLFLT)(val3);
21023  ecode4 = SWIG_AsVal_double(args(3), &val4);
21024  if (!SWIG_IsOK(ecode4)) {
21025  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
21026  }
21027  arg4 = (PLFLT)(val4);
21028  ecode5 = SWIG_AsVal_double(args(4), &val5);
21029  if (!SWIG_IsOK(ecode5)) {
21030  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
21031  }
21032  arg5 = (PLFLT)(val5);
21033  ecode6 = SWIG_AsVal_double(args(5), &val6);
21034  if (!SWIG_IsOK(ecode6)) {
21035  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
21036  }
21037  arg6 = (PLFLT)(val6);
21038  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
21039  _outv = octave_value();
21040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21041  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21042  return _out;
21043 fail:
21044  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21045  return octave_value_list();
21046 }
21047 
21048 
21049 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
21050  mapform_func arg1 = (mapform_func) 0 ;
21051  PLFLT arg2 ;
21052  PLFLT arg3 ;
21053  PLFLT arg4 ;
21054  PLFLT arg5 ;
21055  PLFLT arg6 ;
21056  PLFLT arg7 ;
21057  double val2 ;
21058  int ecode2 = 0 ;
21059  double val3 ;
21060  int ecode3 = 0 ;
21061  double val4 ;
21062  int ecode4 = 0 ;
21063  double val5 ;
21064  int ecode5 = 0 ;
21065  double val6 ;
21066  int ecode6 = 0 ;
21067  double val7 ;
21068  int ecode7 = 0 ;
21069  octave_value_list _out;
21070  octave_value_list *_outp=&_out;
21071  octave_value _outv;
21072 
21073  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
21074  SWIG_fail;
21075  }
21076  {
21077  octave_value obj = args(0);
21078  if ( !obj.is_empty() )
21079  {
21080  if ( obj.is_function_handle() || obj.is_inline_function() )
21081  {
21082  fcnMapForm = obj.function_value();
21083  }
21084  else if ( obj.is_string() )
21085  {
21086  nameMapForm = obj.string_value();
21087  fcnMapForm = NULL;
21088  }
21089  arg1 = mapform_octave;
21090  }
21091  else
21092  {
21093  arg1 = NULL;
21094  }
21095  }
21096  ecode2 = SWIG_AsVal_double(args(1), &val2);
21097  if (!SWIG_IsOK(ecode2)) {
21098  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
21099  }
21100  arg2 = (PLFLT)(val2);
21101  ecode3 = SWIG_AsVal_double(args(2), &val3);
21102  if (!SWIG_IsOK(ecode3)) {
21103  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
21104  }
21105  arg3 = (PLFLT)(val3);
21106  ecode4 = SWIG_AsVal_double(args(3), &val4);
21107  if (!SWIG_IsOK(ecode4)) {
21108  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
21109  }
21110  arg4 = (PLFLT)(val4);
21111  ecode5 = SWIG_AsVal_double(args(4), &val5);
21112  if (!SWIG_IsOK(ecode5)) {
21113  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
21114  }
21115  arg5 = (PLFLT)(val5);
21116  ecode6 = SWIG_AsVal_double(args(5), &val6);
21117  if (!SWIG_IsOK(ecode6)) {
21118  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
21119  }
21120  arg6 = (PLFLT)(val6);
21121  ecode7 = SWIG_AsVal_double(args(6), &val7);
21122  if (!SWIG_IsOK(ecode7)) {
21123  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
21124  }
21125  arg7 = (PLFLT)(val7);
21126  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
21127  _outv = octave_value();
21128  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21129  return _out;
21130 fail:
21131  return octave_value_list();
21132 }
21133 
21134 
21136  octave_value_list _out;
21137  octave_value_list *_outp=&_out;
21138  octave_value _outv;
21139 
21140  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
21141  SWIG_fail;
21142  }
21143  plClearOpts();
21144  _outv = octave_value();
21145  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21146  return _out;
21147 fail:
21148  return octave_value_list();
21149 }
21150 
21151 
21153  octave_value_list _out;
21154  octave_value_list *_outp=&_out;
21155  octave_value _outv;
21156 
21157  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
21158  SWIG_fail;
21159  }
21160  plResetOpts();
21161  _outv = octave_value();
21162  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21163  return _out;
21164 fail:
21165  return octave_value_list();
21166 }
21167 
21168 
21170  char *arg1 = (char *) 0 ;
21171  char *arg2 = (char *) 0 ;
21172  int res1 ;
21173  char *buf1 = 0 ;
21174  int alloc1 = 0 ;
21175  int res2 ;
21176  char *buf2 = 0 ;
21177  int alloc2 = 0 ;
21178  octave_value_list _out;
21179  octave_value_list *_outp=&_out;
21180  octave_value _outv;
21181 
21182  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
21183  SWIG_fail;
21184  }
21185  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21186  if (!SWIG_IsOK(res1)) {
21187  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
21188  }
21189  arg1 = (char *)(buf1);
21190  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
21191  if (!SWIG_IsOK(res2)) {
21192  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
21193  }
21194  arg2 = (char *)(buf2);
21195  plSetUsage((char const *)arg1,(char const *)arg2);
21196  _outv = octave_value();
21197  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21198  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21199  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21200  return _out;
21201 fail:
21202  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21203  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21204  return octave_value_list();
21205 }
21206 
21207 
21209  octave_value_list _out;
21210  octave_value_list *_outp=&_out;
21211  octave_value _outv;
21212 
21213  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
21214  SWIG_fail;
21215  }
21216  plOptUsage();
21217  _outv = octave_value();
21218  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21219  return _out;
21220 fail:
21221  return octave_value_list();
21222 }
21223 
21224 
21225 
21226 static const struct swig_octave_member swig_globals[] = {
21227 {"testppchar",_wrap_testppchar,0,0,2,0},
21228 {"plGetCursor",_wrap_plGetCursor,0,0,2,0},
21229 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
21230 {"plstripc",_wrap_plstripc,0,0,2,0},
21231 {"plcont",_wrap_plcont,0,0,2,0},
21232 {"plcont0",_wrap_plcont0,0,0,2,0},
21233 {"plcont1",_wrap_plcont1,0,0,2,0},
21234 {"plcont2",_wrap_plcont2,0,0,2,0},
21235 {"plcont2p",_wrap_plcont2p,0,0,2,0},
21236 {"plgriddata",_wrap_plgriddata,0,0,2,0},
21237 {"plmesh",_wrap_plmesh,0,0,2,0},
21238 {"plmeshc",_wrap_plmeshc,0,0,2,0},
21239 {"plot3d",_wrap_plot3d,0,0,2,0},
21240 {"plot3dc",_wrap_plot3dc,0,0,2,0},
21241 {"plsurf3d",_wrap_plsurf3d,0,0,2,0},
21242 {"plshade",_wrap_plshade,0,0,2,0},
21243 {"plshade1",_wrap_plshade1,0,0,2,0},
21244 {"plshade2",_wrap_plshade2,0,0,2,0},
21245 {"plshades",_wrap_plshades,0,0,2,0},
21246 {"plshadesx",_wrap_plshadesx,0,0,2,0},
21247 {"plshades1",_wrap_plshades1,0,0,2,0},
21248 {"plshades2",_wrap_plshades2,0,0,2,0},
21249 {"plvect",_wrap_plvect,0,0,2,0},
21250 {"plvect1",_wrap_plvect1,0,0,2,0},
21251 {"plvect2",_wrap_plvect2,0,0,2,0},
21252 {"pplimage",_wrap_pplimage,0,0,2,0},
21253 {"plimagefr",_wrap_plimagefr,0,0,2,0},
21254 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
21255 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
21256 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
21257 {"plcolorbar",_wrap_plcolorbar,0,0,2,0},
21258 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
21259 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
21260 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
21261 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
21262 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
21263 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
21264 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
21265 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
21266 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
21267 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
21268 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
21269 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
21270 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
21271 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
21272 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
21273 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
21274 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
21275 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
21276 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
21277 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
21278 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
21279 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
21280 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
21281 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
21282 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
21283 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
21284 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
21285 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
21286 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
21287 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
21288 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
21289 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
21290 {"plbtime",_wrap_plbtime,0,0,2,0},
21291 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
21292 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
21293 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
21294 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
21295 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
21296 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
21297 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
21298 {"plconfigtime",_wrap_plconfigtime,0,0,2,0},
21299 {"plctime",_wrap_plctime,0,0,2,0},
21300 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
21301 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
21302 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
21303 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
21304 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
21305 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
21306 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
21307 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
21308 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
21309 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
21310 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
21311 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
21312 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
21313 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
21314 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
21315 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
21316 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
21317 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
21318 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
21319 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
21320 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
21321 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
21322 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
21323 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
21324 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
21325 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
21326 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
21327 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
21328 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
21329 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
21330 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
21331 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
21332 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
21333 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
21334 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
21335 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
21336 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
21337 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
21338 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
21339 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
21340 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
21341 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
21342 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
21343 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
21344 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
21345 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
21346 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
21347 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
21348 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
21349 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
21350 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
21351 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
21352 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
21353 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
21354 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
21355 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
21356 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
21357 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
21358 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
21359 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
21360 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
21361 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
21362 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
21363 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
21364 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
21365 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
21366 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
21367 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
21368 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
21369 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
21370 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
21371 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
21372 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
21373 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
21374 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,0},
21375 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,0},
21376 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
21377 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
21378 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
21379 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
21380 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
21381 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
21382 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
21383 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
21384 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
21385 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
21386 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
21387 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
21388 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
21389 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
21390 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
21391 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
21392 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
21393 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
21394 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
21395 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
21396 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
21397 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
21398 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
21399 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
21400 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
21401 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
21402 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
21403 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
21404 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
21405 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
21406 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
21407 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
21408 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
21409 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
21410 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
21411 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
21412 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
21413 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
21414 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
21415 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
21416 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
21417 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
21418 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
21419 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
21420 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
21421 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
21422 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
21423 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
21424 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
21425 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
21426 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
21427 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
21428 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
21429 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
21430 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
21431 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
21432 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
21433 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
21434 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
21435 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
21436 {0,0,0,0,0}
21437 };
21438 
21439 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
21440 
21441 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
21442 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
21443 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
21444 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};
21445 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};
21446 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};
21447 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
21448 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
21449 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
21450 
21453  &_swigt__p_char,
21458  &_swigt__p_int,
21461 };
21462 
21463 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
21464 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
21465 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
21469 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
21470 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
21471 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
21472 
21480  _swigc__p_int,
21483 };
21484 
21485 
21486 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
21487 
21488 /* -----------------------------------------------------------------------------
21489  * Type initialization:
21490  * This problem is tough by the requirement that no dynamic
21491  * memory is used. Also, since swig_type_info structures store pointers to
21492  * swig_cast_info structures and swig_cast_info structures store pointers back
21493  * to swig_type_info structures, we need some lookup code at initialization.
21494  * The idea is that swig generates all the structures that are needed.
21495  * The runtime then collects these partially filled structures.
21496  * The SWIG_InitializeModule function takes these initial arrays out of
21497  * swig_module, and does all the lookup, filling in the swig_module.types
21498  * array with the correct data and linking the correct swig_cast_info
21499  * structures together.
21500  *
21501  * The generated swig_type_info structures are assigned staticly to an initial
21502  * array. We just loop through that array, and handle each type individually.
21503  * First we lookup if this type has been already loaded, and if so, use the
21504  * loaded structure instead of the generated one. Then we have to fill in the
21505  * cast linked list. The cast data is initially stored in something like a
21506  * two-dimensional array. Each row corresponds to a type (there are the same
21507  * number of rows as there are in the swig_type_initial array). Each entry in
21508  * a column is one of the swig_cast_info structures for that type.
21509  * The cast_initial array is actually an array of arrays, because each row has
21510  * a variable number of columns. So to actually build the cast linked list,
21511  * we find the array of casts associated with the type, and loop through it
21512  * adding the casts to the list. The one last trick we need to do is making
21513  * sure the type pointer in the swig_cast_info struct is correct.
21514  *
21515  * First off, we lookup the cast->type name to see if it is already loaded.
21516  * There are three cases to handle:
21517  * 1) If the cast->type has already been loaded AND the type we are adding
21518  * casting info to has not been loaded (it is in this module), THEN we
21519  * replace the cast->type pointer with the type pointer that has already
21520  * been loaded.
21521  * 2) If BOTH types (the one we are adding casting info to, and the
21522  * cast->type) are loaded, THEN the cast info has already been loaded by
21523  * the previous module so we just ignore it.
21524  * 3) Finally, if cast->type has not already been loaded, then we add that
21525  * swig_cast_info to the linked list (because the cast->type) pointer will
21526  * be correct.
21527  * ----------------------------------------------------------------------------- */
21528 
21529 #ifdef __cplusplus
21530 extern "C" {
21531 #if 0
21532 } /* c-mode */
21533 #endif
21534 #endif
21535 
21536 #if 0
21537 #define SWIGRUNTIME_DEBUG
21538 #endif
21539 
21540 
21541 SWIGRUNTIME void
21542 SWIG_InitializeModule(void *clientdata) {
21543  size_t i;
21544  swig_module_info *module_head, *iter;
21545  int found, init;
21546 
21547  /* check to see if the circular list has been setup, if not, set it up */
21548  if (swig_module.next==0) {
21549  /* Initialize the swig_module */
21550  swig_module.type_initial = swig_type_initial;
21551  swig_module.cast_initial = swig_cast_initial;
21552  swig_module.next = &swig_module;
21553  init = 1;
21554  } else {
21555  init = 0;
21556  }
21557 
21558  /* Try and load any already created modules */
21559  module_head = SWIG_GetModule(clientdata);
21560  if (!module_head) {
21561  /* This is the first module loaded for this interpreter */
21562  /* so set the swig module into the interpreter */
21563  SWIG_SetModule(clientdata, &swig_module);
21564  module_head = &swig_module;
21565  } else {
21566  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
21567  found=0;
21568  iter=module_head;
21569  do {
21570  if (iter==&swig_module) {
21571  found=1;
21572  break;
21573  }
21574  iter=iter->next;
21575  } while (iter!= module_head);
21576 
21577  /* if the is found in the list, then all is done and we may leave */
21578  if (found) return;
21579  /* otherwise we must add out module into the list */
21580  swig_module.next = module_head->next;
21581  module_head->next = &swig_module;
21582  }
21583 
21584  /* When multiple interpreters are used, a module could have already been initialized in
21585  a different interpreter, but not yet have a pointer in this interpreter.
21586  In this case, we do not want to continue adding types... everything should be
21587  set up already */
21588  if (init == 0) return;
21589 
21590  /* Now work on filling in swig_module.types */
21591 #ifdef SWIGRUNTIME_DEBUG
21592  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
21593 #endif
21594  for (i = 0; i < swig_module.size; ++i) {
21595  swig_type_info *type = 0;
21596  swig_type_info *ret;
21597  swig_cast_info *cast;
21598 
21599 #ifdef SWIGRUNTIME_DEBUG
21600  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21601 #endif
21602 
21603  /* if there is another module already loaded */
21604  if (swig_module.next != &swig_module) {
21605  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
21606  }
21607  if (type) {
21608  /* Overwrite clientdata field */
21609 #ifdef SWIGRUNTIME_DEBUG
21610  printf("SWIG_InitializeModule: found type %s\n", type->name);
21611 #endif
21612  if (swig_module.type_initial[i]->clientdata) {
21613  type->clientdata = swig_module.type_initial[i]->clientdata;
21614 #ifdef SWIGRUNTIME_DEBUG
21615  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
21616 #endif
21617  }
21618  } else {
21619  type = swig_module.type_initial[i];
21620  }
21621 
21622  /* Insert casting types */
21623  cast = swig_module.cast_initial[i];
21624  while (cast->type) {
21625 
21626  /* Don't need to add information already in the list */
21627  ret = 0;
21628 #ifdef SWIGRUNTIME_DEBUG
21629  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
21630 #endif
21631  if (swig_module.next != &swig_module) {
21632  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
21633 #ifdef SWIGRUNTIME_DEBUG
21634  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
21635 #endif
21636  }
21637  if (ret) {
21638  if (type == swig_module.type_initial[i]) {
21639 #ifdef SWIGRUNTIME_DEBUG
21640  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
21641 #endif
21642  cast->type = ret;
21643  ret = 0;
21644  } else {
21645  /* Check for casting already in the list */
21646  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
21647 #ifdef SWIGRUNTIME_DEBUG
21648  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
21649 #endif
21650  if (!ocast) ret = 0;
21651  }
21652  }
21653 
21654  if (!ret) {
21655 #ifdef SWIGRUNTIME_DEBUG
21656  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
21657 #endif
21658  if (type->cast) {
21659  type->cast->prev = cast;
21660  cast->next = type->cast;
21661  }
21662  type->cast = cast;
21663  }
21664  cast++;
21665  }
21666  /* Set entry in modules->types array equal to the type */
21667  swig_module.types[i] = type;
21668  }
21669  swig_module.types[i] = 0;
21670 
21671 #ifdef SWIGRUNTIME_DEBUG
21672  printf("**** SWIG_InitializeModule: Cast List ******\n");
21673  for (i = 0; i < swig_module.size; ++i) {
21674  int j = 0;
21675  swig_cast_info *cast = swig_module.cast_initial[i];
21676  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
21677  while (cast->type) {
21678  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21679  cast++;
21680  ++j;
21681  }
21682  printf("---- Total casts: %d\n",j);
21683  }
21684  printf("**** SWIG_InitializeModule: Cast List ******\n");
21685 #endif
21686 }
21687 
21688 /* This function will propagate the clientdata field of type to
21689 * any new swig_type_info structures that have been added into the list
21690 * of equivalent types. It is like calling
21691 * SWIG_TypeClientData(type, clientdata) a second time.
21692 */
21693 SWIGRUNTIME void
21695  size_t i;
21696  swig_cast_info *equiv;
21697  static int init_run = 0;
21698 
21699  if (init_run) return;
21700  init_run = 1;
21701 
21702  for (i = 0; i < swig_module.size; i++) {
21703  if (swig_module.types[i]->clientdata) {
21704  equiv = swig_module.types[i]->cast;
21705  while (equiv) {
21706  if (!equiv->converter) {
21707  if (equiv->type && !equiv->type->clientdata)
21708  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21709  }
21710  equiv = equiv->next;
21711  }
21712  }
21713  }
21714 }
21715 
21716 #ifdef __cplusplus
21717 #if 0
21718 { /* c-mode */
21719 #endif
21720 }
21721 #endif
21722 
21723 
21724 
21725 static bool SWIG_init_user(octave_swig_type* module_ns);
21726 
21727 SWIGINTERN bool SWIG_Octave_LoadModule(std::string name) {
21728  bool retn;
21729  {
21730 #if OCTAVE_API_VERSION_NUMBER < 38
21731  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
21732  unwind_protect_int(error_state);
21733  unwind_protect_int(warning_state);
21734  unwind_protect_bool(discard_error_messages);
21735  unwind_protect_bool(discard_warning_messages);
21736 #else
21737  unwind_protect frame;
21738  frame.protect_var(error_state);
21739  frame.protect_var(warning_state);
21740  frame.protect_var(discard_error_messages);
21741  frame.protect_var(discard_warning_messages);
21742 #endif
21743  error_state = 0;
21744  warning_state = 0;
21745  discard_error_messages = true;
21746  discard_warning_messages = true;
21747  feval(name, octave_value_list(), 0);
21748  retn = (error_state == 0);
21749 #if OCTAVE_API_VERSION_NUMBER < 38
21750  unwind_protect::run_frame("SWIG_Octave_LoadModule");
21751 #endif
21752  }
21753  if (!retn) {
21754  error(SWIG_name_d ": could not load module `%s'", name.c_str());
21755  }
21756  return retn;
21757 }
21758 
21759 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
21760  bool retn;
21761  {
21762 #if OCTAVE_API_VERSION_NUMBER < 38
21763  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
21764  unwind_protect_int(error_state);
21765  unwind_protect_int(warning_state);
21766  unwind_protect_bool(discard_error_messages);
21767  unwind_protect_bool(discard_warning_messages);
21768 #else
21769  unwind_protect frame;
21770  frame.protect_var(error_state);
21771  frame.protect_var(warning_state);
21772  frame.protect_var(discard_error_messages);
21773  frame.protect_var(discard_warning_messages);
21774 #endif
21775  error_state = 0;
21776  warning_state = 0;
21777  discard_error_messages = true;
21778  discard_warning_messages = true;
21779  octave_value_list args;
21780  args.append(name);
21781  args.append(octloadfcn->fcn_file_name());
21782  error_state = 0;
21783  feval("autoload", args, 0);
21784  retn = (error_state == 0);
21785 #if OCTAVE_API_VERSION_NUMBER < 38
21786  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
21787 #endif
21788  }
21789  if (!retn) {
21790  error(SWIG_name_d ": could not load function `%s'", name.c_str());
21791  }
21792  return retn;
21793 }
21794 
21795 static const char *const subclass_usage = "-*- texinfo -*- \n\
21796 @deftypefn {Loadable Function} {} subclass()\n\
21797 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
21798 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
21799 \n\
21800 See the SWIG manual for usage examples.\n\
21801 @end deftypefn";
21802 
21803 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
21805  for (int j = 0; j < args.length(); ++j) {
21806  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
21807  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
21808  octave_swig_type *ost = osr->get_ptr();
21809  if (!ost->is_owned()) {
21810  error("subclass: cannot subclass object not constructed on octave side");
21811  return octave_value_list();
21812  }
21813  top->merge(*ost);
21814  } else if (args(j).is_function_handle()) {
21815  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
21816  } else if (args(j).is_string()) {
21817  if (j + 1 >= args.length()) {
21818  error("subclass: member assignments must be of string,value form");
21819  return octave_value_list();
21820  }
21821  top->assign(args(j).string_value(), args(j + 1));
21822  ++j;
21823  } else {
21824  error("subclass: invalid arguments to subclass()");
21825  return octave_value_list();
21826  }
21827  }
21828  return octave_value(Swig::swig_value_ref(top));
21829 }
21830 
21831 static const char *const swig_type_usage = "-*- texinfo -*- \n\
21832 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
21833 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
21834 @end deftypefn";
21835 
21836 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
21837  if (args.length() != 1) {
21838  error("swig_type: must be called with only a single object");
21839  return octave_value_list();
21840  }
21841  octave_swig_type *ost = Swig::swig_value_deref(args(0));
21842  if (!ost) {
21843  error("swig_type: object is not a swig_ref");
21844  return octave_value_list();
21845  }
21846  return octave_value(ost->swig_type_name());
21847 }
21848 
21849 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
21850 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
21851 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
21852 otherwise return `<unknown>'.\n\
21853 @end deftypefn";
21854 
21855 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
21856  if (args.length() != 1 || !args(0).is_string()) {
21857  error("swig_typequery: must be called with single string argument");
21858  return octave_value_list();
21859  }
21860  swig_module_info *module = SWIG_GetModule(0);
21861  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
21862  if (!type)
21863  return octave_value("<unknown>");
21864  return octave_value(type->name);
21865 }
21866 
21867 static const char *const swig_this_usage = "-*- texinfo -*- \n\
21868 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
21869 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
21870 @end deftypefn";
21871 
21872 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
21873  if (args.length() != 1) {
21874  error("swig_this: must be called with only a single object");
21875  return octave_value_list();
21876  }
21877  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
21878  return octave_value(octave_uint64(0));
21879  octave_swig_type *ost = Swig::swig_value_deref(args(0));
21880  if (!ost) {
21881  error("swig_this: object is not a swig_ref");
21882  return octave_value_list();
21883  }
21884  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
21885 }
21886 
21887 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
21888 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
21889 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
21890 @end deftypefn";
21891 
21892 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
21893 
21894  static octave_swig_type* module_ns = 0;
21895 
21896  // workaround to prevent octave seg-faulting on exit: set Octave exit function
21897  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
21898  // definitely affects version 3.2.*, not sure about 3.3.*, seems to be fixed in
21899  // version 3.4.* and above. can be turned off with macro definition.
21900 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
21901 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
21902  octave_exit = ::_Exit;
21903 #endif
21904 #endif
21905 
21906  // check for no input and output args
21907  if (args.length() != 0 || nargout != 0) {
21908  print_usage();
21909  return octave_value_list();
21910  }
21911 
21912  // create module on first function call
21913  if (!module_ns) {
21914 
21915  // workaround bug in octave where installing global variable of custom type and then
21916  // exiting without explicitly clearing the variable causes octave to segfault.
21917 #if OCTAVE_API_VERSION_NUMBER > 36
21918  octave_value_list eval_args;
21919  eval_args.append("base");
21920  eval_args.append("function __swig_atexit__; "
21921  " if mislocked() "
21922  " clear -all; "
21923  " else "
21924  " mlock(); "
21925  " endif; "
21926  "endfunction; "
21927  "__swig_atexit__; "
21928  "atexit(\"__swig_atexit__\", false); "
21929  "atexit(\"__swig_atexit__\")");
21930  feval("evalin", eval_args, 0);
21931 #endif
21932 
21933  octave_swig_ref::register_type();
21934  octave_swig_packed::register_type();
21937 
21938  octave_function *me = octave_call_stack::current();
21939 
21940  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
21941  return octave_value_list();
21942  }
21943  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
21944  return octave_value_list();
21945  }
21946  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
21947  return octave_value_list();
21948  }
21949  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
21950  return octave_value_list();
21951  }
21952 
21953  octave_swig_type* cvar_ns=0;
21954  if (std::string(SWIG_global_name) != ".") {
21955  cvar_ns=new octave_swig_type;
21956  for (int j=0;swig_globals[j].name;++j)
21957  if (swig_globals[j].get_method)
21958  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
21959  }
21960 
21961  module_ns=new octave_swig_type(0, 0, 0, true);
21962  if (std::string(SWIG_global_name) != ".") {
21963  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
21964  }
21965  else {
21966  for (int j=0;swig_globals[j].name;++j)
21967  if (swig_globals[j].get_method)
21968  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21969  }
21970  for (int j=0;swig_globals[j].name;++j)
21971  if (swig_globals[j].method)
21972  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21973 
21974  // * need better solution here; swig_type -> octave_class mapping is
21975  // * really n-to-1, in some cases such as template partial spec, etc.
21976  // * see failing tests.
21977  for (int j=0;swig_types[j];++j)
21978  if (swig_types[j]->clientdata) {
21979  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
21980  module_ns->assign(c->name,
21982  (new octave_swig_type(0,swig_types[j])));
21983  }
21984 
21985  if (!SWIG_init_user(module_ns)) {
21986  delete module_ns;
21987  module_ns=0;
21988  return octave_value_list();
21989  }
21990 
21991  SWIG_InstallOps(octave_swig_ref::static_type_id());
21992 
21994  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
21995  if (mb->second.first && mb->second.first->method) {
21996  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
21997  return octave_value_list();
21998  }
21999  }
22000  }
22001 
22002 #if OCTAVE_API_VERSION_NUMBER < 37
22003  mlock(me->name());
22004 #else
22005  mlock();
22006 #endif
22007 
22008  }
22009 
22011  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
22012  if (mb->second.second.is_defined()) {
22013  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
22014  SWIG_Octave_LinkGlobalValue(mb->first);
22015  }
22016  }
22017 
22018  SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
22019  SWIG_Octave_LinkGlobalValue(SWIG_name_d);
22020 
22021  return octave_value_list();
22022 
22023 }
22024 
22025 
22026 static bool SWIG_init_user(octave_swig_type* module_ns)
22027 {
22028  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
22029  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
22030  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
22031  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
22032  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
22033  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
22034  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
22035  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
22036  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
22037  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
22038  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
22039  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
22040  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
22041  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
22042  SWIG_Octave_SetConstant(module_ns,"PLESC_PLFLTBUFFERING",SWIG_From_int((int)(15)));
22043  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
22044  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
22045  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
22046  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
22047  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
22048  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
22049  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
22050  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x01)));
22051  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x02)));
22052  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x03)));
22053  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x04)));
22054  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x08)));
22055  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x10)));
22056  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x20)));
22057  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x40)));
22058  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x80)));
22059  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
22060  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0)));
22061  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(1)));
22062  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(2)));
22063  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(4)));
22064  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0)));
22065  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(1)));
22066  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(2)));
22067  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(8)));
22068  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(16)));
22069  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(1)));
22070  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(2)));
22071  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(4)));
22072  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(8)));
22073  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(16)));
22074  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(32)));
22075  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(64)));
22076  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(128)));
22077  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(1)));
22078  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(2)));
22079  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(4)));
22080  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(8)));
22081  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(16)));
22082  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(32)));
22083  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(64)));
22084  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(128)));
22085  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
22086  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
22087  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
22088  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
22089  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
22090  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
22091  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
22092  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
22093  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
22094  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
22095  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
22096  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
22097  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
22098  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
22099  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
22100  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
22101  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
22102  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
22103  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
22104  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
22105  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
22106  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
22107  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
22108  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
22109  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
22110  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
22111  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
22112  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
22113  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
22114  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
22115  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
22116  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
22117  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
22118  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
22119  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
22120  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
22121  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
22122  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
22123  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
22124  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
22125  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
22126  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
22127  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
22128  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
22129  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
22130  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
22131  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
22132  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
22133  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
22134  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
22135  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
22136  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
22137  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
22138  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
22139  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
22140  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
22141  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
22142  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
22143  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
22144  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
22145  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
22146  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
22147  SWIG_Octave_SetConstant(module_ns,"PLESPLFLTBUFFERING_ENABLE",SWIG_From_int((int)(1)));
22148  SWIG_Octave_SetConstant(module_ns,"PLESPLFLTBUFFERING_DISABLE",SWIG_From_int((int)(2)));
22149  SWIG_Octave_SetConstant(module_ns,"PLESPLFLTBUFFERING_QUERY",SWIG_From_int((int)(3)));
22150  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
22151  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
22152  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
22153  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
22154  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
22155  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
22156  return true;
22157 }
22158 
static const char * _wrap_pljoin_texinfo
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsOK(r)
static const swig_type_info * swig_PLGraphicsIn_base[]
static swig_cast_info _swigc__p_int[]
subroutine plbox(xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:148
std::string nameMapForm
static const char * _wrap_pladv_texinfo
#define plsfam
Definition: plplot.h:709
#define plw3d
Definition: plplot.h:754
void merge(octave_swig_type &rhs)
#define swigreg_binary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
octave_swig_type(const octave_swig_type &x)
static const char * _wrap_plcol0_texinfo
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLINT text
Definition: gcw.c:97
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swig_binary_op(name)
static const char * name
Definition: tkMain.c:131
static const char * _wrap_pl_setcontlabelformat_texinfo
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
static bool SWIG_init_user(octave_swig_type *module_ns)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsmin_texinfo
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_function * fcnLabelFunc
static const char * _wrap_plsyax_texinfo
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgxax
Definition: plplot.h:642
static const char * swig_PLGraphicsIn_base_names[]
#define plsstrm
Definition: plplot.h:727
static const char *const swig_typequery_usage
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const subclass_usage
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const * label
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plschr_texinfo
#define plspage
Definition: plplot.h:723
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
#define plvpor
Definition: plplot.h:752
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plszax_texinfo
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
static const char * _wrap_plscolbga_texinfo
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
static const char * _wrap_plSetOpt_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT nx
static PLFLT ** xg
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plerry
Definition: plplot.h:610
#define SWIG_GetModule(clientdata)
PLFLT * xg
Definition: plplot.h:428
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsyax
Definition: plplot.h:744
#define SWIG_OK
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pltimefmt_texinfo
#define plschr
Definition: plplot.h:683
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plstripa_texinfo
octave_base_value * empty_clone() const
subroutine plmtex3(side, disp, pos, xjust, text)
Definition: sfstubs.f90:722
PLFLT dX
Definition: plplot.h:362
virtual bool is_object() const
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyObject * swig_this
int min(int a, int b)
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
subroutine plsfnam(fnam)
Definition: sfstubs.f90:92
#define SWIG_RUNTIME_VERSION
static const char * _wrap_plsori_texinfo
#define pllegend
Definition: plplot.h:653
static const char * _wrap_plstransform_texinfo
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_map() const
#define SWIG_POINTER_OWN
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
std::string swig_type_name() const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT bb_color
static const char * _wrap_plscmap1a_texinfo
virtual bool save_ascii(std::ostream &os)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
static const char * _wrap_plgcol0a_texinfo
#define SWIGTYPE_p_PLGraphicsIn
void PLFLT PLINT PLINT position
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT const PLINT * n_values
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
#define plshade
Definition: plplot.h:713
#define plscompression
Definition: plplot.h:699
#define plarc
Definition: plplot.h:588
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
std::string nameLabelFunc
static const char * _wrap_plstripd_texinfo
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
PLUINT PLUNICODE
Definition: plplot.h:195
subroutine plstring3(x, y, z, string)
Definition: sfstubs.f90:327
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static const char * _wrap_plmeridians_texinfo
virtual Octave_map map_value() const
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static const char * _wrap_plmtex3_texinfo
#define plot3dc
Definition: plplot.h:667
void plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, int npts, PLFLT *xg, int nptsx, PLFLT *yg, int nptsy, PLFLT **zg, int type, PLFLT data)
static const char * _wrap_plpoin_texinfo
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllsty
Definition: plplot.h:658
#define SWIG_SystemError
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmin
Definition: plplot.h:720
#define plwind
Definition: plplot.h:757
#define plclear
Definition: plplot.h:596
void c_plshades(const PLFLT *const *a, PLINT nx, PLINT ny, PLINT(*defined)(PLFLT, PLFLT), PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, const PLFLT *clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, void(*fill)(PLINT, const PLFLT *, const PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
Definition: plshade.c:205
#define plfill
Definition: plplot.h:612
#define plconfigtime
Definition: plplot.h:600
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpoin3_texinfo
void plimage(PLFLT **data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
#define plbtime
Definition: plplot.h:594
subroutine plmtex(side, disp, pos, xjust, text)
Definition: sfstubs.f90:705
void c_plvect(const PLFLT *const *u, const PLFLT *const *v, PLINT nx, PLINT ny, PLFLT scale, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
Definition: plvect.c:216
#define pl_setcontlabelparam
Definition: plplot.h:586
#define SWIGTYPE_p_p_char
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolbg
Definition: plplot.h:696
swig_dycast_func dcast
static swig_type_info _swigt__p_double
char string[PL_MAXKEY]
Definition: plplot.h:360
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
struct swig_cast_info * cast
static const char * _wrap_plsstrm_texinfo
#define plfont
Definition: plplot.h:615
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
#define plstyl
Definition: plplot.h:738
static const char * _wrap_plgspa_texinfo
#define PL_MAXKEY
Definition: plplot.h:351
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
#define SWIG_OLDOBJ
#define plpoly3
Definition: plplot.h:673
subroutine plstring(x, y, string)
Definition: sfstubs.f90:309
#define SWIGINTERN
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
swig_type_info * type
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define plfontld
Definition: plplot.h:616
subroutine plgdev(dnam)
Definition: sfstubs.f90:80
static const char * _wrap_plenv0_texinfo
#define plscolbga
Definition: plplot.h:697
#define plbin
Definition: plplot.h:590
PLFLT * yg
Definition: plplot.h:428
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdiori
Definition: plplot.h:703
static const char * _wrap_plpsty_texinfo
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plparseopts
Definition: plplot.h:669
#define plsym
Definition: plplot.h:745
#define plscmap1
Definition: plplot.h:687
std::map< std::string, member_value_pair > member_map
#define plinit
Definition: plplot.h:650
void PLFLT PLINT PLINT PLFLT x
virtual std::string string_value(bool force=false) const
tuple xmin
Definition: Plframe.py:907
#define plctime
Definition: plplot.h:603
#define plscmap1n
Definition: plplot.h:691
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void load_members(const swig_octave_class *c, member_map &out) const
static const char * _wrap_plgfont_texinfo
#define plbop
Definition: plplot.h:591
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int error
Definition: plcont.c:67
octave_swig_type * get_ptr() const
static swig_type_info _swigt__p_p_char
#define plsdiplt
Definition: plplot.h:704
for(i=0;i< nx;i++) if(n_values[i]< ny) ny
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsvect
Definition: plplot.h:741
#define plscmap1a
Definition: plplot.h:688
#define plssub
Definition: plplot.h:728
member_map::const_iterator swig_member_const_iterator
static const char * _wrap_plstring_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
dim_vector dims(void) const
#define SWIG_ConvertPtr(obj, pptr, type, flags)
void * PLPointer
Definition: plplot.h:201
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmeshc
Definition: plplot.h:662
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbox3_texinfo
#define plgcompression
Definition: plplot.h:622
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
#define SWIG_name
#define plszax
Definition: plplot.h:746
#define plvsta
Definition: plplot.h:753
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
octave_base_value * clone() const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT const PLINT const PLFLT * a
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void plshade1(PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, void(*fill)(PLINT, PLFLT *, PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdidev_texinfo
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _n_dims(const octave_value &o_obj)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
tuple ymin
Definition: Plframe.py:908
#define plgpage
Definition: plplot.h:633
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsori
Definition: plplot.h:722
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const * axis_opts
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
void c_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plot3d.c:326
#define plgdiplt
Definition: plplot.h:626
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static const char *const SWIG_name_usage
#define plscmap0a
Definition: plplot.h:685
#define SWIG_TypeError
PLINT ny
Definition: plplot.h:441
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static PLFLT ** yg
static int my_plGetCursor(int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfamadv
Definition: plplot.h:611
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plarc_texinfo
static const char * _wrap_plwind_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
subroutine plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)
Definition: sfstubs.f90:166
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
#define plend
Definition: plplot.h:604
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT low_cap_color
static const char * _wrap_plgdiori_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
static const char * _wrap_plstring3_texinfo
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsfont_texinfo
static swig_cast_info _swigc__p_double[]
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static PLINT Xlen
#define plmap
Definition: plplot.h:659
#define plgfont
Definition: plplot.h:631
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define plend1
Definition: plplot.h:605
static const char * _wrap_plgcompression_texinfo
int PLINT
Definition: plplot.h:175
#define plenv0
Definition: plplot.h:607
void c_plimagefr(const PLFLT *const *idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
Definition: plimage.c:194
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
#define plgdiori
Definition: plplot.h:625
static const char * _wrap_plgyax_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual string_vector map_keys() const
#define plshades
Definition: plplot.h:715
static const char * _wrap_plgstrm_texinfo
PLINT PLBOOL
Definition: plplot.h:198
static swig_type_info _swigt__p_char
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plstyl_texinfo
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pleop_texinfo
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:729
static const char * _wrap_plgcol0_texinfo
static const char * _wrap_plgchr_texinfo
static const char * _wrap_plbox_texinfo
#define pljoin
Definition: plplot.h:651
#define plgzax
Definition: plplot.h:644
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_plgfci_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgfam
Definition: plplot.h:628
octave_function * fcnMapForm
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_pllightsource_texinfo
static octave_value make_value_hack(const octave_base_value &x)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgver_texinfo
int plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:255
PLINT ny
Definition: plplot.h:429
#define plgdidev
Definition: plplot.h:624
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plgra_texinfo
#define plstar
Definition: plplot.h:730
static const char * _wrap_plsvect_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
static const char * _wrap_plsfnam_texinfo
void * cast(swig_type_info *type, int *_own, int flags)
static const char * _wrap_plgfam_texinfo
octave_function * fcnCoordTrans
const char * help_text() const
virtual bool load_ascii(std::istream &is)
virtual bool is_object() const
swig_member_const_iterator swig_members_begin()
#define plcpstrm
Definition: plplot.h:602
static const char * _wrap_plspage_texinfo
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
#define plcalc_world
Definition: plplot.h:595
void assign(const std::string &name, const swig_octave_member *m)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void assign(const std::string &name, const octave_value &ov)
static const char * _wrap_plreplot_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
#define plhist
Definition: plplot.h:645
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
octave_swig_ref(octave_swig_type *_ptr=0)
static const char *const swig_type_usage
static const char * _wrap_plsmaj_texinfo
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static PLINT Ylen
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgchr
Definition: plplot.h:617
#define SWIG_exception_fail(code, msg)
struct swig_module_info * next
plGetCursor
Definition: plplotc.py:6962
#define plsdidev
Definition: plplot.h:701
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SetModule(clientdata, pointer)
static const char * _wrap_plvasp_texinfo
#define SWIG_ERROR
static const char * _wrap_plvsta_texinfo
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
plSetUsage
Definition: plplotc.py:6950
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscompression_texinfo
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plfill3
Definition: plplot.h:613
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
octave_value operator*() const
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plgver(ver)
Definition: sfstubs.f90:117
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT y
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
swig_converter_func converter
PLFLT ** xg
Definition: plplot.h:440
subroutine plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)
Definition: sfstubs.f90:130
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plsfam_texinfo
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
octave_base_value * clone() const
static const char * _wrap_plsdidev_texinfo
#define plseed
Definition: plplot.h:706
#define SWIGTYPE_p_unsigned_int
plOptUsage
Definition: plplotc.py:6954
#define plstransform
Definition: plplot.h:732
#define plvect
Definition: plplot.h:750
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
#define SWIG_as_voidptr(a)
int plSetOpt(const char *opt, const char *opt_arg)
Definition: plargs.c:738
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plgradient_texinfo
#define SWIG_DelNewMask(r)
#define SWIG_ArgError(r)
void load_members(member_map &out) const
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plend1_texinfo
virtual bool is_map() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static const char * _wrap_plspal0_texinfo
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plscmap1_texinfo
#define plscmap1la
Definition: plplot.h:690
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssub_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plpat_texinfo
#define plcont
Definition: plplot.h:601
#define plsxax
Definition: plplot.h:743
plClearOpts
Definition: plplotc.py:6942
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
subroutine plspal0(filename)
Definition: sfstubs.f90:676
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
static const char * _wrap_plgvpd_texinfo
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pleop
Definition: plplot.h:608
#define plmesh
Definition: plplot.h:661
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plhlsrgb
Definition: plplot.h:647
swig_type_info ** types
std::string nameCoordTrans
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgvpw_texinfo
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
#define SWIG_IsNewObj(r)
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsmaj
Definition: plplot.h:717
PLINT nx
Definition: plplot.h:441
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plvpor_texinfo
gint count
Definition: gcw-lib.c:726
bool dispatch_unary_op(const std::string &symbol, octave_value &ret)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
static const char * _wrap_plflush_texinfo
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plfill3_texinfo
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
#define SWIGTYPE_p_int
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol1
Definition: plplot.h:598
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define pllightsource
Definition: plplot.h:654
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT high_cap_color
static const char * _wrap_plprec_texinfo
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
pl_setcontlabelformat
Definition: tclgen_s.h:1
static const char * _wrap_plstar_texinfo
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
static const char * _wrap_plseed_texinfo
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool is_string() const
#define pltext
Definition: plplot.h:747
virtual bool save_ascii(std::ostream &os)
virtual bool save_ascii(std::ostream &os)
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plptex_texinfo
octave_swig_type & operator=(const octave_swig_type &rhs)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plwidth
Definition: plplot.h:756
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static const char * _wrap_plscmap0n_texinfo
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscolbg_texinfo
void c_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plot3d.c:881
#define plscol0a
Definition: plplot.h:695
void c_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
subroutine plsetopt(opt, optarg)
Definition: sfstubs.f90:39
#define plsdiplz
Definition: plplot.h:705
unsigned int keysym
Definition: plplot.h:357
static const char * _wrap_plsdev_texinfo
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define plspause
Definition: plplot.h:726
const swig_type_info ** base
static swig_type_info * swig_types[10]
subroutine plptex(x, y, dx, dy, xjust, text)
Definition: sfstubs.f90:739
tuple xmax
Definition: Plframe.py:909
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline3
Definition: plplot.h:657
#define plstripd
Definition: plplot.h:737
#define plgfci
Definition: plplot.h:629
#define plgspa
Definition: plplot.h:637
#define plgcolbg
Definition: plplot.h:620
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
#define plstripc
Definition: plplot.h:736
DEFUN_DLD(subclass, args, nargout, subclass_usage)
#define plstripa
Definition: plplot.h:735
static const char * _wrap_plgzax_texinfo
void
Definition: f95/scstubs.c:588
#define SWIG_global_name
static const char * _wrap_plenv_texinfo
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT cont_color
subroutine plgfnam(fnam)
Definition: sfstubs.f90:105
#define SWIG_NEWOBJ
static const char * _wrap_plscmap1l_texinfo
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvpas
Definition: plplot.h:751
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
#define plsfont
Definition: plplot.h:712
void my_plshadesx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, PLFLT *tr)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLGraphicsIn
subroutine pllab(xlab, ylab, title)
Definition: sfstubs.f90:658
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define f2c(f, ff, nx, ny)
#define SWIG_IsTmpObj(r)
static const char * _wrap_plfontld_texinfo
#define plpsty
Definition: plplot.h:675
static const char * _wrap_plerry_texinfo
PLFLT ** yg
Definition: plplot.h:440
static const char * _wrap_plline3_texinfo
static const char * _wrap_plscmap1n_texinfo
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1203
#define plgvpd
Definition: plplot.h:640
static swig_octave_class _wrap_class_PLGraphicsIn
#define plpoin
Definition: plplot.h:671
#define plgvpw
Definition: plplot.h:641
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT wX
Definition: plplot.h:363
#define SWIGRUNTIMEINLINE
PLINT subwindow
Definition: plplot.h:359
static swig_cast_info _swigc__p_unsigned_int[]
subroutine plsdev(dnam)
Definition: sfstubs.f90:67
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IndexError
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_plgcolbg_texinfo
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plrandd_texinfo
int max(int a, int b)
void c_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:858
static const char * _wrap_plspal1_texinfo
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
static const char * _wrap_plmtex_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plfont_texinfo
static const char *const swig_this_usage
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
#define SWIG_AttributeError
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
static const char * _wrap_plline_texinfo
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT x_length
static const char * _wrap_plbop_texinfo
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_name_d
void my_plcont2(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmkstrm
Definition: plplot.h:663
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type= '"') const
float PLFLT
Definition: plplot.h:159
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
#define plscol0
Definition: plplot.h:694
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_pltext_texinfo
#define plxormod
Definition: plplot.h:758
static const char * _wrap_plxormod_texinfo
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plerrx_texinfo
#define plflush
Definition: plplot.h:614
#define plerrx
Definition: plplot.h:609
#define plgcol0a
Definition: plplot.h:619
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IOError
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define plgcolbga
Definition: plplot.h:621
static const char * _wrap_plsdiplt_texinfo
static const char * _wrap_plfill_texinfo
static const char * _wrap_plpoly3_texinfo
static const char * _wrap_plscolor_texinfo
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscol0a_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plsym_texinfo
static const char * _wrap_plbin_texinfo
void PLFLT PLINT opt
#define SWIG_AddCast(r)
PLINT(* defined_func)(PLFLT, PLFLT)
#define plgyax
Definition: plplot.h:643
#define plsesc
Definition: plplot.h:707
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plenv
Definition: plplot.h:606
static PLINT Alen
#define swigreg_unary_op(name)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT cont_width
swig_member_const_iterator swig_members_end()
static const char * _wrap_plsesc_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
struct swig_cast_info * next
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plw3d_texinfo
void PLFLT * p_colorbar_height
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
static const char * _wrap_plglevel_texinfo
#define SWIG_op_prefix
subroutine plspal1(filename, interpolate)
Definition: sfstubs.f90:690
const swig_octave_member * members
#define plgcmap1_range
Definition: plplot.h:693
#define plcol0
Definition: plplot.h:597
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT bb_style
#define SWIG_RuntimeError
SWIGRUNTIME void SWIG_InstallOps(int tid)
virtual std::string string_value(bool force=false) const
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static int _arraylen(const octave_value &o_obj)
tuple ymax
Definition: Plframe.py:910
static swig_cast_info * swig_cast_initial[]
static const char * _wrap_plstart_texinfo
unsigned int state
Definition: plplot.h:356
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
subroutine plstart(devname, nx, ny)
Definition: sfstubs.f90:769
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
#define SWIG_fail
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:632
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_pllab_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref,"swig_ref","swig_ref")
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static const char * _wrap_plgpage_texinfo
#define SWIG_ValueError
#define plpoin3
Definition: plplot.h:672
struct swig_cast_info swig_cast_info
static const struct swig_octave_member swig_globals[]
static const char * _wrap_plsdiplz_texinfo
#define plscmap0n
Definition: plplot.h:686
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
std::pair< const swig_octave_member *, octave_value > member_value_pair
subroutine plptex3(x, y, z, dx, dy, dz, sx, sy, sz, xjust, text)
Definition: sfstubs.f90:754
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolor
Definition: plplot.h:698
#define plsvpa
Definition: plplot.h:742
octave_value_ref(const octave_value_list &_ovl, int _j)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpat
Definition: plplot.h:670
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1_range
Definition: plplot.h:692
#define SWIG_POINTER_DISOWN
static const char * _wrap_plcalc_world_texinfo
struct swig_cast_info * prev
static const char * _wrap_plcol1_texinfo
#define plgcol0
Definition: plplot.h:618
static const char * _wrap_plslabelfunc_texinfo
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
#define plreplot
Definition: plplot.h:679
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
swig_cast_info ** cast_initial
octave_value_list(* octave_func)(const octave_value_list &, int)
void c_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline[], const char *labx, const char *laby, const char *labtop)
Definition: plstripc.c:68
static const char * _wrap_plmkstrm_texinfo
unsigned int button
Definition: plplot.h:358
static swig_type_info * swig_type_initial[]
#define SWIG_DEFUN(cname, wname, doc)
static const char * _wrap_plrgbhls_texinfo
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbga_texinfo
#define swig_unary_op(name)
#define plscmap1l
Definition: plplot.h:689
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT bg_color
static const char * _wrap_plgfnam_texinfo
#define plprec
Definition: plplot.h:674
#define SWIG_DivisionByZero
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plcpstrm_texinfo
virtual Octave_map map_value() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT * label_opts
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmap_texinfo
const swig_type_info * construct_type
static const char * _wrap_pllsty_texinfo
virtual bool is_string() const
#define plline
Definition: plplot.h:655
if not
Definition: sfstubs.h:19
PLFLT dY
Definition: plplot.h:362
#define SWIG_MemoryError
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT const PLINT * sub_ticks
static const char * _wrap_pllegend_texinfo
static const char * _wrap_plptex3_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
void my_plshade1(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define plgradient
Definition: plplot.h:635
static const char * _wrap_plclear_texinfo
static const char * _wrap_plaxes_texinfo
const octave_value_list & ovl
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsdiori_texinfo
swig_type_info ** type_initial
static const char * _wrap_plend_texinfo
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plscol0_texinfo
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
#define pladv
Definition: plplot.h:587
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT const PLINT const char *const PLINT const char *const const PLFLT * ticks
#define plvasp
Definition: plplot.h:749
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrandd
Definition: plplot.h:678
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmeridians
Definition: plplot.h:660
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plshade(const PLFLT *const *a, PLINT nx, PLINT ny, PLINT(*defined)(PLFLT, PLFLT), PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void(*fill)(PLINT, const PLFLT *, const PLFLT *), PLINT rectangular, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
Definition: plshade.c:321
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plcont(const PLFLT *const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, void(*pltr)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
Definition: plcont.c:515
#define plscmap0
Definition: plplot.h:684
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssym_texinfo
static int _dim(const octave_value &o_obj, int dim_idx)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * empty_clone() const
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgstrm
Definition: plplot.h:638
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info swig_type_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
#define plsfci
Definition: plplot.h:710
static swig_octave_member swig_PLGraphicsIn_members[]
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
PLFLT wY
Definition: plplot.h:363
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plfamadv_texinfo
plResetOpts
Definition: plplotc.py:6946
subroutine pltimefmt(fmt)
Definition: sfstubs.f90:784
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
static const char * _wrap_plgxax_texinfo
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plrgbhls
Definition: plplot.h:682
#define plsurf3d
Definition: plplot.h:739
void plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *label, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values) void my_plcolorbar(PLFLT *p_colorbar_width
static const char * _wrap_plspause_texinfo
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char *const *labels, PLINT n_axes, const char *const *axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *const *values)
Definition: pllegend.c:1463
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgra
Definition: plplot.h:634
void c_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plot3d.c:150
#define plsdimap
Definition: plplot.h:702
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsvpa_texinfo
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
dim_vector dims(void) const
static swig_cast_info _swigc__p_PLGraphicsIn[]
static const char * _wrap_plvpas_texinfo
#define plot3d
Definition: plplot.h:666
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT y_length
#define plslabelfunc
Definition: plplot.h:716
PLINT nx
Definition: plplot.h:429
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
static const char * _wrap_plscmap0_texinfo
#define SWIG_NewPointerObj(ptr, type, flags)
std::vector< type_ptr_pair > types
void PLFLT PLINT PLINT PLFLT PLFLT PLFLT PLFLT PLINT PLINT PLINT PLFLT PLFLT PLINT PLFLT PLINT n_labels
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plhist_texinfo
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)